← overview

mino

Implemented
75.5%751 / 995 vars
Reported clojure-version
1.11.0
Clojure (JVM) Version
1.12.4
Snapshot Taken
2026-05-23 16:05 UTC

Per-Namespace Implementation

NamespaceImplementedMismatchedMissingDialect-Only
clojure.core82.5%560 / 67978119184
clojure.core.protocols72.7%8 / 11034
clojure.core.reducers61.9%13 / 21081
clojure.data20.0%1 / 5040
clojure.datafy100.0%2 / 2000
clojure.edn100.0%2 / 2000
clojure.instant60.0%3 / 5022
clojure.math68.9%31 / 450140
clojure.pprint11.5%3 / 260230
clojure.set100.0%12 / 12000
clojure.spec.alpha56.3%49 / 8718388
clojure.string100.0%21 / 21000
clojure.template100.0%2 / 2100
clojure.test20.5%8 / 3943112
clojure.walk80.0%8 / 10020
clojure.zip100.0%28 / 28000

Documented Extensions (4)

Vars in this surface that are intentionally outside Clojure (JVM), as documented in the dialect's registry.

Collection semantics1 entry

  • Keyword-based bitmask matching primitive

    Since
    v0.422.0
    Affected Vars
    • clojure.core/bits-kw-match
    Rationale
    Bit-level pattern matching against a keyword's internal representation. Designed for embedded use cases where bits-and-bytes ergonomics beat structural collection ops.
JVM-static value remap3 entries

  • C++ RAII wrappers in mino.hpp

    Since
    v0.421.0
    Affected Vars
    • clojure.core/cpp-wrappers
    Rationale
    Optional C++ header (mino.hpp) gives embedders RAII semantics over mino_state lifecycle and value ownership. Not a Clojure-visible API; documented here to flag that mino's embedding surface extends beyond the C ABI.

  • JVM static method mirrors for integer radix conversion

    Since
    v0.422.5
    Affected Vars
    • clojure.core/Integer/toBinaryString
    • clojure.core/Integer/toHexString
    • clojure.core/Integer/toOctalString
    • clojure.core/Long/toBinaryString
    • clojure.core/Long/toHexString
    • clojure.core/Long/toOctalString
    Rationale
    Clojure code that calls Integer/toBinaryString etc. is fairly common; mino mirrors these as named bindings so portable code does not need to special- case mino. The implementation is in C, exposed via the jvm_statics module.

  • Monotonic-clock primitive

    Since
    v0.166.0
    Affected Vars
    • clojure.core/time-ms
    Rationale
    mino-native replacement for (System/currentTimeMillis). Returns milliseconds since an implementation-defined epoch; suitable for measuring elapsed time within a single process.

Documented Intentional Divergences (28)

Decisions where this surface intentionally departs from Clojure (JVM), as documented in the dialect's registry.

Ordering & comparison2 entries

  • compare returns sign-only (-1, 0, 1)

    Since
    v0.1.0
    Rationale
    Hickey-test for what compare's contract is: a three-way ordering function. Sign-normalized return values are simpler and avoid leaking representation-specific deltas.

  • sorted-map default comparator does not handle mixed types

    Since
    v0.98.0
    Rationale
    Cross-type comparison was closed in v0.98; mixed- type sorted-map keys without an explicit comparator may throw rather than coerce.
Type-system representation4 entries

  • class behaves like type -- no JVM-class semantics

    Since
    v0.1.0
    Rationale
    There are no classes; class is provided as a Clojure-shaped alias rather than a separate abstraction.

  • deftype is an alias for defrecord without map-like ops

    Since
    v0.1.0
    Rationale
    deftype's volatile-field and interface-impl features depend on JVM semantics. mino provides deftype as a structural type carrier; the JVM- only knobs are no-ops.

  • defrecord types are not Java classes

    Since
    v0.1.0
    Rationale
    mino's records carry identity, field slots, and a type keyword -- no host-level class is generated. instance? on a record uses the type keyword as its discriminator.

  • type returns a keyword, not a Java class

    Since
    v0.1.0
    Rationale
    No JVM classes. mino's type system is keyword- tagged (:vector, :map, :list, :symbol, ...). Dispatch logic that pattern-matches on classes must use the keyword tags instead.
Numeric tower3 entries

  • Float-32 is a distinct numeric type

    Since
    v0.1.0
    Rationale
    mino exposes a 32-bit float-tagged value for space-constrained embedded use; Clojure (JVM) collapses to Double.

  • = on cross-type numbers follows Clojure (JVM), not JVM =

    Since
    v0.1.0
    Rationale
    = remains a value-equality predicate; numeric equality across float / int is what Clojure (JVM) specifies, not JVM-Object-equality.

  • Single integer type -- no Long/Integer/Short distinction

    Since
    v0.1.0
    Rationale
    mino has no JVM types; one integer representation suffices. Promotion within the integer tier never happens because there is only one tier.
Reader behavior1 entry

  • Reader conditional :clj does not fire under mino

    Since
    v0.1.0
    Rationale
    mino is not JVM Clojure; portable code must use :default or :mino to target it. Documented and intentional.
Printer behavior2 entries

  • CLI default for *print-namespace-maps* is true

    Since
    v0.422.0
    Rationale
    mino's CLI alters the var-root to true on startup so user-facing prints collapse qualified-key maps. bb and JVM Clojure do the same; library use sees the documented false default.

  • pprint is minimal -- no cl-format directives

    Since
    v0.1.0
    Rationale
    mino's clojure.pprint supports pretty-printing basic forms; cl-format and table directives are not implemented. Targets the common case.
Collection semantics3 entries

  • Sequence chunking is deterministic but not always 32

    Since
    v0.1.0
    Rationale
    Lazy realization batch size is implementation- defined in Clojure (JVM); mino picks sizes that suit the embedded use case. Code that depends on exact chunk boundaries is non-portable in Clojure (JVM) too.

  • clojure.spec generators ship as separate primitives

    Since
    v0.1.0
    Rationale
    mino's spec.alpha implements the documented surface; clojure.spec.gen.alpha is partially present and may diverge from clojure.test.check behavior on edge cases.

  • transit reader/writer are not bundled

    Since
    v0.1.0
    Rationale
    Transit is a JVM artifact in Clojure (JVM) distributions; mino does not bundle it. EDN remains the wire format.
Concurrency primitives1 entry

  • Atoms, refs, futures, agents have alpha-quality

    Since
    v0.1.0
    Rationale
    mino runs single-threaded in the embedded host; concurrency primitives are present but the underlying execution model is cooperative, not preemptive.
Error message shapes3 entries

  • clojure.test reports via mino's counters, not JVM clojure.test/report

    Since
    v0.422.0
    Rationale
    Per-assertion error isolation matches Clojure (JVM)'s contract. The underlying report mechanism uses mino-native counters and prints rather than the JVM clojure.test/report multimethod.

  • Error messages and ex-info keys may differ

    Since
    v0.1.0
    Rationale
    Exception text is implementation-defined in Clojure (JVM). mino's messages aim to be informative but are not byte-for-byte JVM-Clojure-compatible. Use ex-data / ex-cause / category keys to dispatch.

  • ex-info / throw use mino-native exception type

    Since
    v0.1.0
    Rationale
    No JVM Throwable. mino's exception type is its own runtime value with :message and :data fields; instance checks via clojure.lang.ExceptionInfo do not work.
JVM-static value remap6 entries

  • clojure.java.io namespace is intentionally absent

    Since
    v0.1.0
    Rationale
    mino's host I/O is exposed via mino-native primitives that do not match File / InputStream abstractions. clojure.java.io is excluded from parity comparison.

  • gen-class is not provided

    Since
    v0.1.0
    Rationale
    gen-class emits JVM bytecode. mino has no Java interop layer.

  • clojure.repl is intentionally absent

    Since
    v0.1.0
    Rationale
    Repl support is environment-bound and uses embedder-specific input/output. doc, source, apropos are exposed at the CLI rather than in a namespace.

  • Integer/MAX_VALUE etc. remapped or absent

    Since
    v0.1.0
    Rationale
    mino exposes a curated subset of JVM-static-name values (Integer/toBinaryString, Long/toHexString, ...) for Clojure code that depends on them. Most are absent.

  • No clojure.reflect -- JVM-only

    Since
    v0.1.0
    Rationale
    Reflection is meaningless without a JVM. mino's introspection uses ns-publics + meta, not class inspection.

  • proxy is not provided

    Since
    v0.1.0
    Rationale
    proxy generates a JVM class -- no equivalent in mino. defrecord + protocols cover the same use case in a host-portable way.
Namespace mechanics1 entry

  • Namespaced keyword aliasing uses runtime aliases

    Since
    v0.1.0
    Rationale
    ::alias/kw is resolved at read time against the current ns's aliases -- same as JVM Clojure, but mino's reader does not have access to the JVM classloader hierarchy.
Metadata propagation2 entries

  • Reader-tracked :file may be relative or absolute

    Since
    v0.1.0
    Rationale
    mino's reader records the path as the embedder passed it; JVM Clojure normalizes to classpath- relative. Tools that compare :file values must accept either.

  • Reader attaches {:line :column} to lists only

    Since
    v0.422.0
    Rationale
    mino mirrors JVM Clojure: per-cons reader meta is accessible through meta; literal vectors/maps/sets receive no per-instance reader meta.

Drift Since 2026-05-22

Added Vars
0
Removed Vars
0
Changed Vars
0
Implementation Delta
+0.0000

History (2 Snapshots)

DateImplementedVars
2026-05-2375.5%751 / 995
2026-05-2275.5%751 / 995