Clojure Q&A - Recent questions tagged clojureclr

How to use core.async from cljr command line tool?

Mon, 24 Nov 2025 06:05:40 +0000

At some point it would be good to facilitate use of core.async from cljr command line tool (clr.core.cli).

I think what's required is:

add a deps-clr.edn to clojure/tools.analyzer
add a deps-clr.edn to clojure/tools.analyzer.clr (depends on tools.analyzer, clr.tools.reader, clr.core.memoize -> clr.core.cache -> clr.data.priority-map)
add a deps-clr.edn to clojure/clr.core.async
also, archive clojure/clr.tools.analyzer

This is not urgent because it's possible to procure core.async from NuGet but it would be convenient if it could also be procured via git.

Does cljr -Sdeps work for other people?

Mon, 01 Sep 2025 23:26:42 +0000

Putting the dependencies in a deps-clr.edn file works.

But not via cljr -Sdeps. E.g.: try to launch nREPL server:
$ cljr -Sdeps '{:deps {io.github.clojure/clr.tools.nrepl {:git/tag "v0.1.2-alpha2"}}}' -X clojure.tools.nrepl/start-server! Clojure core loaded in 4177 milliseconds. Starting exec/tool Clojure core loaded in 4207 milliseconds. Namespace could not be loaded: clojure.tools.nrepl

I did custom compile some things so wondering if it's just me. The README for clr.core.cli says -Sdeps is supported.

I can malform the string and seems to throw no errors, I don't think it's being processed.

Well I'll poke around and report back what I find meanwhile.

Porting clojure libraries w/ java interop to clojure-clr

Fri, 15 Aug 2025 01:31:53 +0000

I've been browsing around to understand the ecosystem.

I see some libraries are ported to use CLR interop, like core.logic, some are part way finished, like core.async.

Here is one maintainer's concerns, they would much like to point CLR users at a fork with CLR interop maintained by someone else:
https://github.com/weavejester/medley/pull/96
https://github.com/weavejester/medley/pull/65

For fun I examined how to use formal logic to do the code translation. Using Spec, and core.logic for code generation perhaps. I think it would require a lot of knowledge representation.

It might be easier, for these non-core/crucial libraries to use LLMs to do the code translation, and direct the outputs into a set of forks. Perhaps the core libraries used as training data on what to do. This author has some great insights and details on a plausible workflow(s) including with the utility of editor integration. He has done interop translation and work with clojure:
https://m.youtube.com/watch?v=oNhqqiKuUmw

As it is only the interop which requires translation (subsets of clojure files), with a skilled hand there might be better results than some of what he illustrates.

I looked around for a spec for the dotnet core API. I saw one they used to maintain but couldn't find a recent one. Though, all this LLM stuff is beyond me at this time. I thought to share some of my exploration.

EDIT: Found the dotnet API spec/reference for netstandard 2.1.0, I think someone wrote they since moved it into dotnet/runtime but I couldn't find it there, dunno if this helps: https://github.com/dotnet/standard/blob/v2.1.0/src/netstandard/ref/System.IO.cs

Does clojure-clr work on Android?

Sat, 19 Apr 2025 19:59:28 +0000

EDIT: Answer is YES. Below is my long-winded exploration.

I see one of the reasons for clojure-clr-next is it will work on more platforms, is Android one of those?

I'm using Termux to operate dotnet on Android.

Both the clojure-clr global dotnet tool and locally compiled clojure-clr fail with exit code 1, no exceptions or anything. I tried dotnet-trace and it gets a partial trace, but no minidump. Puzzling as with the partial trace, the documentation indicates an expectation of a minidump, maybe there is some unmet condition to emit the minidump I'm not aware of yet (env variables for it didn't work).

In the trace here is an early line followed by some of the last lines:
`
"system.linq!System.Linq.Enumerable.SelectManyS\ingleSelectorIterator\u003cSystem.Reflection.As\sembly,System.Type\u003e.MoveNext()"

[...]
"system.collections!System.Collections.Generic.\
SortedSet\u003cSystem.Collections.Generic.KeyVa\luePair\u003cSystem.Int32,clojure.lang.CljCompi\ler.Ast.FnMethod\u003e\u003e.AddIfNotPresent(Sy\stem.Collections.Generic.KeyValuePair`2\u003cin\t,

[...last line...]
"ManagedModule!System.Buffers.SharedArrayPool\u\003cSystem.Byte\u003e.Trim()"
`

So maybe something to do with reflection, or that SharedArrayPool?

I tried inserting some logging to Clojure.Main, but nothing logged as it appears to fail before CljMain.Main() is called. Possibly fails during setting up attributes on one of the classes, in one of the Symbol.intern() or RT.var() calls or somewhere else?

Couldn't run the dotnet msbuild build.proj -t:Test -p:TestTargetFramework=net8.0, fails with:
Clojure.Main -> /data/data/com.termux/files/home/dev/clojure-clr/Clojure/Clojure.Main/bin/Debug/net8.0/Clojure.Main.dll ClojureCompileAssets = '' ClojureMainAssets = '' ClojureTestsAssets = '' /data/data/com.termux/files/home/dev/clojure-clr/Clojure/build.proj(177,5): error MSB3073: The command "dotnet run --project /data/data/com.termux/files/home/dev/clojure-clr/Clojure/Clojure.Main --framework net8.0 -c Debug -p:TargetOS=linux-bionic -p:TargetPlatform=arm64 -p:TargetFramework=net8.0 -p:TargetFrameworks='net8.0' -- run_test.clj" exited with code 1.
I had to edit build.proj a bit to get custom -p:TargetFrameworks and such to pass through, but still fails with exit code 1.

Well I'll continue poking around in this uncharted territory.

CLR behavior of tools.namespace does not match the JVM implementation

Thu, 05 Dec 2024 14:44:05 +0000

I noticed a few behavioral differences between the CLR and JVM implementations of tools.namespace.

As an example, the following tests will pass in the JVM implementation and fail in the CLR implementation. In CLR, files-2 is empty and ::dir/time is an instant.

(ns clojure.tools.namespace.repl-test
  (:require [clojure.test :refer [deftest is]]
            [clojure.tools.namespace.dir :as dir]
            [clojure.tools.namespace.find :as find]
            [clojure.tools.namespace.repl :as repl]
            [clojure.tools.namespace.test-helpers :as help]))

(deftest t-repl-scan
  (let [dir        (help/create-temp-dir "t-repl-scan")
        _main-clj  (help/create-source dir 'example.main :clj '[example.one])
        _one-cljc  (help/create-source dir 'example.one :clj)
        _other-dir (help/create-temp-dir "t-repl-scan-other")
        files-1    (::dir/files (repl/scan {:platform find/clj}))
        files-2    (::dir/files (repl/scan {:platform find/clj}))]
    (is (not-empty files-1))
    (is (not-empty files-2))
    (is (= files-1 files-2))))

(deftest t-repl-scan-time
  (let [scan (repl/scan {:platform find/clj})]
    (is (integer? (::dir/time scan)))))

After discussing with other contributors, the question of intent came up and this test was proposed as something that correctly captures the intent of repl/scan. However, if this is the intended behavior, then a new problem arises as this test fails in the JVM implementation.

(deftest t-repl-scan
  (try
    (let [dir       (help/create-temp-dir "t-repl-scan")
          _main-clj (help/create-source dir 'example.main :clj '[example.one])
          _one-cljc (help/create-source dir 'example.one :clj)
          other-dir (help/create-temp-dir "t-repl-scan-other")
          _         (repl/set-refresh-dirs dir other-dir)
          scan1     (repl/scan {:platform find/clj})
          scan2     (repl/scan {:platform find/clj})
          files-1   (::dir/files scan1)
          files-2   (::dir/files scan2)]
      (is (= (count files-1) 2))
      (is (= (count files-2) 0)))
    (finally (repl/clear))))

A couple things I think would help here:
1. Flesh out the tools.namespace (JVM) test suite to capture all the intended behavior.
2. Realign clr.tools.namespace with tools.namespace.

Point 1 will provide a good baseline for point 2, as well as any other existing/future ports of tools.namespace and help prevent things from diverging in the future as changes are made.

Note

As of writing, repl/scan will throw an InvalidCastException on CLR. To fix this, replace clojure.tools.namespace.dir/modified-files with this:

(defn- modified-files [tracker files]
  (filter #(DateTime/op_LessThan ^DateTime (::time tracker System.DateTime/UnixEpoch) (.get_LastWriteTimeUtc ^FileSystemInfo %)) files))

Porting .NET 4.8 application using Clojure CLR to .NET 8

Sat, 12 Oct 2024 15:55:56 +0000

I am porting a C# application (AutoCAD plugin to be exact) from .NET 4.8 to .NET 8.

The code uses some Clojure CLR.
In .NET 4.8 the clojure namespaces were compiled to assemblies (.dll files) using Clojure.Compile.
At runtime, these namespaces were then loaded using clojure.lang.RT.load

However, precompiling clojure clr code is not possible in .NET 8. (https://ask.clojure.org/index.php/13866/is-still-possible-compile-cljr-files-dll-exe-dotent-and-above)

If I understood correctly, the recommended approach is to include the clojure sources with the application and then load the clojure namespaces using clojure.clr.api.Clojure class?
I could not find any examples or documentation on how to set up my application / environment so that clojure.core/load will find my .clj files.

On page
https://github.com/clojure/clojure-clr/wiki/Using-ClojureCLR-in-a-C#-project
there is instructions on how to invoke clojure.core/load

IFn load= clojure.clr.api.Clojure.var("clojure.core", "load");
load.invoke("some.thing");

However, clojure.core/load is documented to use CLASSPATH to find namespaces. Does this also apply in Cojure CLR, i.e. should I define an appropriate CLASSPATH environment variable before calling clojure.core/load ?
https://clojuredocs.org/clojure.core/load