# mojoshelf — all tin cards

One markdown card per tin (source tins first, then modular-community channel mirrors). Index: https://mojoshelf.org/llms.txt

---

# arrow-mlake-mojo (source tin on mojoshelf, git-pinned per published version)

Apache Arrow memory layout and C Data Interface in pure Mojo — a stopgap until marrow builds on Mojo 1.x

- package name (registry/conda): `arrow-mlake-mojo`
- Mojo import name: `arrow_mlake` (e.g. `from arrow_mlake import …`)
- author: winding-lines
- tags: arrow, c-data-interface, columnar, ffi, magmalake
- repository: https://github.com/magmalake/arrow-mlake.mojo.git
- latest version: 0.1.0 (commit b0b751079079)
- activity: 0 stars, last push 2026-09-08T02:44:52Z, 0 commits last month / 0 last year

## Install

```sh
pixi shelf add arrow-mlake-mojo    # pixi mode: registry-pinned git source dependency
shelf add arrow-mlake-mojo         # submodule mode: pinned source under shelf/arrow-mlake-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/arrow-mlake.mojo.git --rev b0b75107907983a87903b421d1b4b10cbff1c9f0 arrow-mlake-mojo
```

## API surface

### src/arrow_mlake/arrow.mojo

- `struct ArrowType(Copyable, Movable, Writable)`
- `struct ArrayData(Copyable, Movable)`
- `struct ArrayArena(Copyable, Defaultable, Movable)`

### src/arrow_mlake/batch.mojo

- `struct RecordBatch(Copyable, Defaultable, Movable)`

### src/arrow_mlake/carrow.mojo

- `struct ArrowSchema { const char* format; const char* name; const char* metadata;`
- `struct ArrowArray  { int64_t length; int64_t null_count; int64_t offset;`
- `struct CArrowSchema(Copyable, Movable)`
- `struct CArrowArray(Copyable, Movable)`
- `struct _Block(Movable)`
- `struct ExportedArray(Movable)`

### src/arrow_mlake/carrow_import.mojo

- `struct ArrowArrayStream {`
- `struct ImportedArray(Movable)`
- `struct CArrowArrayStream(Copyable, Movable)`
- `struct ImportedStream(Movable)`

## Usage (from the README)

```mojo
from arrow_mlake import (
    ArrayArena, ArrayData, ArrowType, RecordBatch,
    ImportedArray, ImportedStream,
    export_c, import_c, import_batch_c, parse_format,
)
```

---

# avro-mojo (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo Apache Avro — schemas, binary codec, Object Container Files, deflate/snappy/zstd

- package name (registry/conda): `avro-mojo`
- Mojo import name: `avro` (e.g. `from avro import …`)
- author: winding-lines
- tags: avro, iceberg, data-lake, serialization, ocf
- repository: https://github.com/magmalake/avro.mojo.git
- latest version: 0.3.2 (commit 589f3893627e)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-05T18:06:06Z, 35 commits last month / 35 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:45Z)

## Install

```sh
pixi shelf add avro-mojo    # pixi mode: registry-pinned git source dependency
shelf add avro-mojo         # submodule mode: pinned source under shelf/avro-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/avro.mojo.git --rev 589f3893627ee4263c756f679369c1b3f3ca5f7c avro-mojo
```

## API surface

### src/avro/codec.mojo

- `trait CodecSet`
- `struct DefaultCodecs(CodecSet)`

### src/avro/cursor.mojo

- `struct PlanOp(Copyable, Movable)`
- `struct SlotInfo(Copyable, Movable)`
- `struct SlotVal(Copyable, ImplicitlyCopyable, Movable)`
- `struct PlanData(Copyable, Movable)`
- `struct DecodePlan(Copyable, Movable)`
- `struct PlanCache(Movable, Sized)`
- `struct _Builder(Copyable, Movable)`
- `struct RecordCursor[C: CodecSet = DefaultCodecs](Movable)`

### src/avro/datafile.mojo

- `struct DataFileReader[C: CodecSet = DefaultCodecs](Copyable, Movable)`
- `struct DataFileWriter[C: CodecSet = DefaultCodecs](Copyable, Movable)`

### src/avro/decoder.mojo

- `struct Decoder[origin: ImmOrigin](Copyable, Movable)`

## Usage (from the README)

```mojo
from avro import DataFileReader

var r = DataFileReader.open("manifest.avro")
while r.has_next():
    var rec = r.next()
    print(rec.field("manifest_path").as_string())
```

---

# brotli-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo Brotli binding (RFC 7932 compress/decompress) via FFI to libbrotli

- package name (registry/conda): `brotli-mojo`
- Mojo import name: `brotli` (e.g. `from brotli import …`)
- author: winding-lines
- tags: brotli, compression, parquet, rfc7932, ffi, magmalake
- repository: https://github.com/magmalake/brotli.mojo.git
- latest version: 0.1.1 (commit bddf7c6811e7)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-04T17:29:26Z, 10 commits last month / 10 last year

## Install

```sh
pixi shelf add brotli-mojo    # pixi mode: registry-pinned git source dependency
shelf add brotli-mojo         # submodule mode: pinned source under shelf/brotli-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/brotli.mojo.git --rev bddf7c6811e756a4924fb13c7e9c14041644429a brotli-mojo
```

## Usage (from the README)

```mojo
from brotli import compress, decompress, decompress_unsized

# Parquet BROTLI page: the page header carries the uncompressed length.
var page_stream = compress(page_bytes, quality=5)
var page = decompress(page_stream, uncompressed_size)

# Anything that did not record a length (a bare .br blob).
var blob = decompress_unsized(stream_bytes)
```

---

# csv (source tin on mojoshelf, git-pinned per published version)

Read files in the format Comma Separated Values

- package name (registry/conda): `csv`
- Mojo import name: `csv` (e.g. `from csv import …`)
- author: winding-lines
- tags: csv, parsing, data
- repository: https://github.com/millfolio/csv.mojo.git
- latest version: 0.1.3 (commit 667a23f91b22)
- activity: 0 stars, last push 2026-08-29T12:08:18Z, 7 commits last month / 23 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:11:59Z)

## Install

```sh
pixi shelf add csv    # pixi mode: registry-pinned git source dependency
shelf add csv         # submodule mode: pinned source under shelf/csv
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/csv.mojo.git --rev 667a23f91b22546e2320082a59af07ecba56b6fa csv
```

## Usage (from the README)

```mojo
from csv import parse, read

def main() raises:
    var rows = read("statement.csv")     # List[List[String]]
    var rows2 = parse(text)              # parse an in-memory String
    for r in rows:
        ...
```

---

# docx (source tin on mojoshelf, git-pinned per published version)

A from-scratch .docx-to-text extractor in Mojo

- package name (registry/conda): `docx`
- Mojo import name: `docx` (e.g. `from docx import …`)
- author: winding-lines
- tags: docx, documents, text-extraction
- repository: https://github.com/millfolio/docx.mojo.git
- latest version: 0.1.3 (commit 99f540c28ad4)
- depends on: zlib-mojo
- activity: 0 stars, last push 2026-09-06T13:37:51Z, 9 commits last month / 24 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:11:59Z)

## Install

```sh
pixi shelf add docx    # pixi mode: registry-pinned git source dependency
shelf add docx         # submodule mode: pinned source under shelf/docx
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/docx.mojo.git --rev 99f540c28ad4f143b2b75a43b4979d482421d743 docx
```

## API surface

### src/docx/__init__.mojo

- `struct Buf(Movable)`
- `struct ZipEntry(Copyable, Movable)`

## Usage (from the README)

```mojo
def read_file(path: String) raises -> List[UInt8]          # raw .docx bytes
def extract_text(data: List[UInt8]) raises -> String       # the document's text
```

---

# flare_mlake (source tin on mojoshelf, git-pinned per published version)

Packaged build of flare by Ehsan M. Kermani (github.com/ehsanmok/flare) — TCP, UDP, TLS, HTTP/1.1, HTTP/2, HTTP/3, QUIC, WebSocket and gRPC for Mojo. Republished only because flare is not on a conda channel; imported as `flare`. Please send stars and issues upstream.

- package name (registry/conda): `flare_mlake`
- Mojo import name: `flare_mlake` (e.g. `from flare_mlake import …`) — guessed from the tin name, verify in the repo
- author: winding-lines
- tags: flare, networking, http, http2, grpc, tls, websocket, quic, redistribution, magmalake
- repository: https://github.com/magmalake/flare_mlake.git
- latest version: 0.10.0 (commit 441fc0341d78)
- depends on: json_mlake
- activity: 0 stars, last push 2026-09-09T17:43:31Z, 12 commits last month / 838 last year

## Install

```sh
pixi shelf add flare_mlake    # pixi mode: registry-pinned git source dependency
shelf add flare_mlake         # submodule mode: pinned source under shelf/flare_mlake
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/flare_mlake.git --rev 441fc0341d78ccab3598b51b57ebdf30267f5d63 flare_mlake
```

## Usage (from the README)

```mojo
from flare.http import HttpClient
from flare.grpc import ...
```

---

# hashes-mojo (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo CRC-32, MurmurHash3 x86-32, and XXH64 for table-format tooling

- package name (registry/conda): `hashes-mojo`
- Mojo import name: `hashes` (e.g. `from hashes import …`)
- author: winding-lines
- tags: hashing, crc32, murmurhash, xxhash, iceberg, parquet
- repository: https://github.com/magmalake/hashes.mojo.git
- latest version: 0.1.1 (commit 6d56cd46c562)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-05T18:04:22Z, 21 commits last month / 21 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:46Z)

## Install

```sh
pixi shelf add hashes-mojo    # pixi mode: registry-pinned git source dependency
shelf add hashes-mojo         # submodule mode: pinned source under shelf/hashes-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/hashes.mojo.git --rev 6d56cd46c56273051f166d33f50fdf194a8dcd3e hashes-mojo
```

## API surface

### src/hashes/crc32.mojo

- `struct Crc32(Copyable, Movable)`

### src/hashes/xxh64.mojo

- `struct Xxh64(Copyable, Movable)`

## Usage (from the README)

```mojo
from hashes import (
    Crc32, crc32,
    murmur3_x86_32,
    iceberg_bucket, iceberg_hash_bytes, iceberg_hash_decimal,
    iceberg_hash_int, iceberg_hash_long, iceberg_hash_string,
    iceberg_hash_uuid,
    Xxh64, xxh64,
)
```

---

# hungarian-mojo (source tin on mojoshelf, git-pinned per published version)

Jonker-Volgenant rectangular linear assignment in pure Mojo

- package name (registry/conda): `hungarian-mojo`
- Mojo import name: `hungarian` (e.g. `from hungarian import …`)
- author: winding-lines
- tags: assignment, hungarian, tracking, optimization, robotics
- repository: https://github.com/labelrefinery/Hungarian.mojo.git
- latest version: 0.1.0 (commit f20267c62fcf)
- activity: 0 stars, last push 2026-08-29T18:28:32Z, 1 commits last month / 1 last year

## Install

```sh
pixi shelf add hungarian-mojo    # pixi mode: registry-pinned git source dependency
shelf add hungarian-mojo         # submodule mode: pinned source under shelf/hungarian-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/labelrefinery/Hungarian.mojo.git --rev f20267c62fcfbf65b40beaaee7e9801f341ebf93 hungarian-mojo
```

## API surface

### src/hungarian/__init__.mojo

- `struct CostMatrix(Movable)`
- `struct Assignment(Movable)`

## Usage (from the README)

```mojo
from hungarian import CostMatrix, solve_gated, UNASSIGNED

# Rows are tracks, columns are detections. Both tracks are inside the gate for
# detection 0, but only track 1 is inside it for detection 1.
var costs: List[Float64] = [2.0, 90.0, 1.0, 3.0]
var m = CostMatrix(2, 2, costs^)

var a = solve_gated(m, gate=5.0)
# a.col_for_row == [0, 1] -- two matches, total cost 5.0.
# A greedy solver takes the 1.0 cell first and ends up with one match.
```

---

# iceberg-mojo (source tin on mojoshelf, git-pinned per published version)

Native pure-Mojo Apache Iceberg: metadata, manifests, scan planning, multi-core Arrow reads with nested columns, writes, and a SQL catalog over SQLite or PostgreSQL — append, delete, overwrite and deletion vectors

- package name (registry/conda): `iceberg-mojo`
- Mojo import name: `iceberg` (e.g. `from iceberg import …`)
- author: winding-lines
- tags: iceberg, table-format, data-lake, metadata, manifests, arrow, magmalake
- repository: https://github.com/magmalake/iceberg.mojo.git
- latest version: 0.7.2 (commit a3b189158e1b)
- depends on: hashes-mojo, snappy-mojo, zstd-mojo, lz4-mojo, roaring-mojo, thrift-mojo, avro-mojo, parquet-mojo, objectstore-mojo, threads-mojo, sqlite-mojo, brotli-mojo, postgres-mojo
- activity: 0 stars, last push 2026-09-07T17:15:22Z, 88 commits last month / 88 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:46Z)

## Install

```sh
pixi shelf add iceberg-mojo    # pixi mode: registry-pinned git source dependency
shelf add iceberg-mojo         # submodule mode: pinned source under shelf/iceberg-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/iceberg.mojo.git --rev a3b189158e1b2665c79cca6c4376324c82c5af10 iceberg-mojo
```

## API surface

### src/iceberg/append.mojo

- `struct AppendResult(Copyable, Movable)`

### src/iceberg/batch.mojo

- `struct ColumnBuilder(Copyable, Movable, Sized)`
- `struct NestedBuilder(Copyable, Movable, Sized)`

### src/iceberg/commit.mojo

- `struct FileChanges(Copyable, Defaultable, Movable)`
- `struct _Removed(Copyable, Defaultable, Movable)`

### src/iceberg/delete.mojo

- `struct RowDelete(Copyable, Movable)`

## Usage (from the README)

```mojo
from iceberg.catalog.rest import RestCatalog, RestCatalogConfig

var config = RestCatalogConfig("https://catalog.example.com")
config.with_token(token)
config.vend_credentials = True

var catalog = RestCatalog(config^, FileIO.local())
catalog.connect()

var rows = (
    catalog.load_table("db", "orders")
    .scan()
    .filter('["and",[">","id",2],["=","region","eu"]]')
    .select(["id", "region", "amount"])
    .to_table()
)
print(rows.to_csv())
```

---

# iceberg-rs-mojo (source tin on mojoshelf, git-pinned per published version)

Apache Iceberg for Mojo: catalogs, scans and appends over a Rust cdylib wrapping iceberg-rust; first install compiles the shim

- package name (registry/conda): `iceberg-rs-mojo`
- Mojo import name: `iceberg_rs` (e.g. `from iceberg_rs import …`)
- author: winding-lines
- tags: iceberg, lakehouse, arrow, parquet, ffi
- repository: https://github.com/magmalake/iceberg-rs.mojo.git
- latest version: 0.1.0 (commit 9689c5d707f3)
- activity: 0 stars, last push 2026-09-04T02:10:39Z, 20 commits last month / 20 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:46Z)

## Install

```sh
pixi shelf add iceberg-rs-mojo    # pixi mode: registry-pinned git source dependency
shelf add iceberg-rs-mojo         # submodule mode: pinned source under shelf/iceberg-rs-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/iceberg-rs.mojo.git --rev 9689c5d707f3f1970ac923358ae54684995f783c iceberg-rs-mojo
```

## API surface

### src/iceberg_rs/__init__.mojo

- `struct Batch(Movable)`
- `struct ArrowCData(Movable)`
- `struct Scan(Movable)`
- `struct BatchBuilder(Movable)`
- `struct Table(Movable)`
- `struct Catalog(Movable)`

## Usage (from the README)

```mojo
from iceberg_rs import Catalog

def main() raises:
    var cat = Catalog.sql(
        "sqlite:/tmp/demo/catalog.db?mode=rwc", "file:///tmp/demo/warehouse"
    )
    cat.create_namespace("sales")

    var schema = String(
        '{"type":"struct","schema-id":0,"fields":['
        '{"id":1,"name":"id","required":true,"type":"long"},'
        '{"id":2,"name":"region","required":true,"type":"string"},'
        '{"id":3,"name":"amount","required":false,"type":"double"}]}'
    )
    var spec = String(
        '{"spec-id":0,"fields":'
        '[{"source-id":2,"name":"region","transform":"identity"}]}'
    )
    var t = cat.create_table("sales", "orders", schema, spec)

    var b = t.builder()
    b.int_col("id", [Int64(1), Int64(2)])
    b.str_col("region", ["eu", "us"])
    b.float_col("amount", [1.5, 2.5])
    t.append(b.build())
    print("snapshot", t.commit())

    var scan = t.scan("id,amount", '[">","amount",2.0]')
    while True:
        var maybe = scan.next()
```

---

# jinja2-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo implementation of the Jinja2 subset for chat templates

- package name (registry/conda): `jinja2-mojo`
- Mojo import name: `jinja2` (e.g. `from jinja2 import …`)
- author: winding-lines
- tags: templates, jinja2, chat
- repository: https://github.com/millfolio/jinja2.mojo.git
- latest version: 0.1.2 (commit c20707c07eb8)
- activity: 0 stars, last push 2026-08-29T12:08:21Z, 6 commits last month / 25 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:00Z)

## Install

```sh
pixi shelf add jinja2-mojo    # pixi mode: registry-pinned git source dependency
shelf add jinja2-mojo         # submodule mode: pinned source under shelf/jinja2-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/jinja2.mojo.git --rev c20707c07eb85adb1ff056966c4f65d186ad6836 jinja2-mojo
```

## API surface

### src/jinja2/ast.mojo

- `struct ExprNodeList(Copyable, Movable)`
- `struct StmtNodeList(Copyable, Movable)`
- `struct StringList(Copyable, Movable)`
- `struct ExprNode(Copyable, ImplicitlyCopyable, Movable)`
- `struct StmtNode(Copyable, ImplicitlyCopyable, Movable)`

---

# json_mlake (source tin on mojoshelf, git-pinned per published version)

Packaged build of json by Ehsan M. Kermani (github.com/ehsanmok/json) — simdjson-backed JSON parsing for Mojo, CPU and GPU. Republished only because json is not on a conda channel; imported as `json`. Please send stars and issues upstream.

- package name (registry/conda): `json_mlake`
- Mojo import name: `json_mlake` (e.g. `from json_mlake import …`) — guessed from the tin name, verify in the repo
- author: winding-lines
- tags: json, parsing, simdjson, ffi, redistribution, magmalake
- repository: https://github.com/magmalake/json_mlake.git
- latest version: 0.3.0 (commit f80b223bcdde)
- depended on by: flare_mlake
- activity: 0 stars, last push 2026-09-09T16:40:29Z, 0 commits last month / 142 last year

## Install

```sh
pixi shelf add json_mlake    # pixi mode: registry-pinned git source dependency
shelf add json_mlake         # submodule mode: pinned source under shelf/json_mlake
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/json_mlake.git --rev f80b223bcddee2ea6043d5919281f2613c289532 json_mlake
```

---

# kalman-mojo (source tin on mojoshelf, git-pinned per published version)

Kalman filtering and RTS smoothing for offline track refinement, in pure Mojo

- package name (registry/conda): `kalman-mojo`
- Mojo import name: `kalman` (e.g. `from kalman import …`)
- author: winding-lines
- tags: kalman, smoothing, tracking, autolabeling, robotics
- repository: https://github.com/labelrefinery/Kalman.mojo.git
- latest version: 0.1.0 (commit 76bcbfff1252)
- activity: 0 stars, last push 2026-08-29T18:28:34Z, 1 commits last month / 1 last year

## Install

```sh
pixi shelf add kalman-mojo    # pixi mode: registry-pinned git source dependency
shelf add kalman-mojo         # submodule mode: pinned source under shelf/kalman-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/labelrefinery/Kalman.mojo.git --rev 76bcbfff125237108cb218d8f277eab91749c354 kalman-mojo
```

## API surface

### src/kalman/__init__.mojo

- `struct Matrix(Movable)`
- `struct GaussianState(Movable)`
- `struct UpdateResult(Movable)`
- `struct Observation(Movable)`
- `struct SmoothedTrack(Movable)`

## Usage (from the README)

```mojo
from kalman import Observation, GaussianState, Matrix, smooth_track

var obs = List[Observation]()
obs.append(Observation(dt=0.1, z=[10.3]))
obs.append(Observation.gap(dt=0.1))       # occluded, no detection
obs.append(Observation(dt=0.1, z=[10.9]))

var prior = GaussianState([0.0, 0.0], Matrix.identity(2))
var track = smooth_track(
    prior, obs^, dims=1, accel_var=1.0, measurement_var=0.04
)
# track.states[k] is conditioned on the whole sequence, gaps included.
```

---

# labelformer (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo LabelFormer inferencer: LiDAR trajectory auto-label refinement (CoRL 2023)

- package name (registry/conda): `labelformer`
- Mojo import name: `labelformer` (e.g. `from labelformer import …`)
- author: winding-lines
- tags: autolabeling, lidar, transformer, inference, argoverse2
- repository: https://github.com/labelrefinery/LabelFormer.mojo.git
- latest version: 0.1.1 (commit e6cbe43ab4d9)
- activity: 0 stars, last push 2026-09-06T13:37:32Z, 19 commits last month / 19 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:00Z)

## Install

```sh
pixi shelf add labelformer    # pixi mode: registry-pinned git source dependency
shelf add labelformer         # submodule mode: pinned source under shelf/labelformer
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/labelrefinery/LabelFormer.mojo.git --rev e6cbe43ab4d9bfca33538d9d78fe85dbc7994256 labelformer
```

## API surface

### src/labelformer/io.mojo

- `struct Config(Copyable, Movable, Writable)`

---

# lancedb-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo LanceDB binding (vector add/search) via FFI to a Rust cdylib; first install compiles the shim

- package name (registry/conda): `lancedb-mojo`
- Mojo import name: `lancedb` (e.g. `from lancedb import …`)
- author: winding-lines
- tags: vectors, database, lancedb, ffi
- repository: https://github.com/millfolio/lancedb.mojo.git
- latest version: 0.1.5 (commit 2a4f222d8fb4)
- activity: 0 stars, last push 2026-08-29T12:08:23Z, 9 commits last month / 26 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:01Z)

## Install

```sh
pixi shelf add lancedb-mojo    # pixi mode: registry-pinned git source dependency
shelf add lancedb-mojo         # submodule mode: pinned source under shelf/lancedb-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/lancedb.mojo.git --rev 2a4f222d8fb47ce6be2f7acbd4ff3259e55f5289 lancedb-mojo
```

## API surface

### src/lancedb/__init__.mojo

- `struct Store(Movable)`

## Usage (from the README)

```mojo
from lancedb import Store

def main() raises:
    var store = Store("/path/to/vault.db", "chunks", 768)
    store.add(ids, vectors)                 # ids: List[Int64], vectors: row-major List[Float32]
    var hits = store.search(query, 8)       # -> (List[Int64], List[Float32])
    var ids = hits[0]
    var distances = hits[1]
```

---

# lint-mojo (source tin on mojoshelf, git-pinned per published version)

mojolint: a linter for the origin and threading mistakes the Mojo compiler lets through, with mojo-lsp-server behind the rules

- package name (registry/conda): `lint-mojo`
- Mojo import name: `lint` (e.g. `from lint import …`) — guessed from the tin name, verify in the repo
- author: winding-lines
- tags: magmalake, lint, linter, origins, threads, lsp, tooling
- repository: https://github.com/magmalake/lint.mojo.git
- latest version: 0.1.2 (commit 3fa66644756c)
- activity: 0 stars, last push 2026-09-04T00:39:22Z, 10 commits last month / 10 last year

## Install

```sh
pixi shelf add lint-mojo    # pixi mode: registry-pinned git source dependency
shelf add lint-mojo         # submodule mode: pinned source under shelf/lint-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/lint.mojo.git --rev 3fa66644756c1de7aece83e5a89375323b6e0ce7 lint-mojo
```

## API surface

### src/mojolint/facts.mojo

- `struct Facts(Movable)`

### src/mojolint/json.mojo

- `struct JsonNode(Copyable, Movable)`
- `struct JsonDoc(Movable)`
- `struct _Parser[origin: Origin[mut=False]]`

### src/mojolint/lsp.mojo

- `struct Pos(Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct LspBatch(Movable)`
- `struct LspReplies(Movable)`

### src/mojolint/rules.mojo

- `struct Finding(Copyable, Movable, Writable)`
- `struct Rule(Copyable, Movable)`

---

# logging (source tin on mojoshelf, git-pinned per published version)

Timestamped log lines for Mojo, stamped at the moment of the call

- package name (registry/conda): `logging`
- Mojo import name: `logging` (e.g. `from logging import …`)
- author: winding-lines
- tags: logging
- repository: https://github.com/millfolio/logging.mojo.git
- latest version: 0.1.2 (commit d4d0fd32a164)
- activity: 0 stars, last push 2026-08-29T12:08:25Z, 6 commits last month / 18 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:01Z)

## Install

```sh
pixi shelf add logging    # pixi mode: registry-pinned git source dependency
shelf add logging         # submodule mode: pinned source under shelf/logging
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/logging.mojo.git --rev d4d0fd32a164d4b2d8dfae1451d0095b1b6506b3 logging
```

## Usage (from the README)

```mojo
from logging import log

log("server up on :10010")
# → [06:11:04.187] server up on :10010
```

---

# lz4-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo lz4 binding (block + frame format) via FFI to liblz4

- package name (registry/conda): `lz4-mojo`
- Mojo import name: `lz4` (e.g. `from lz4 import …`)
- author: winding-lines
- tags: lz4, compression, parquet, iceberg, puffin, ffi
- repository: https://github.com/magmalake/lz4.mojo.git
- latest version: 0.1.1 (commit 36ec6c5ca1ce)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-05T12:45:29Z, 19 commits last month / 19 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:47Z)

## Install

```sh
pixi shelf add lz4-mojo    # pixi mode: registry-pinned git source dependency
shelf add lz4-mojo         # submodule mode: pinned source under shelf/lz4-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/lz4.mojo.git --rev 36ec6c5ca1cef06c970db67710e072fd64849be7 lz4-mojo
```

## Usage (from the README)

```mojo
from lz4 import compress_block, decompress_block, compress_frame, decompress_frame

# Parquet LZ4_RAW page: no size prefix, caller tracks the uncompressed length.
var block = compress_block(page_bytes)
var page = decompress_block(block, uncompressed_size)

# Iceberg Puffin blob: self-describing frame, content size on by default.
var frame = compress_frame(blob_bytes)
var blob = decompress_frame(frame)
```

---

# moxi (source tin on mojoshelf, git-pinned per published version)

Experimental native reactive UI building blocks and capability contracts for Mojo

- package name (registry/conda): `moxi`
- Mojo import name: `moxi` (e.g. `from moxi import …`)
- author: davidmashburn
- tags: mojo, ui, reactive, accessibility, capability-bus, macos, graphics
- repository: https://github.com/davidmashburn/moxi.git
- latest version: 0.5.1 (commit 57679a1d9099)
- activity: 0 stars, last push 2026-09-06T23:47:37Z, 105 commits last month / 105 last year
- verified: consumer smoke build FAILING (checked 2026-08-31T14:12:01Z)

## Install

```sh
pixi shelf add moxi    # pixi mode: registry-pinned git source dependency
shelf add moxi         # submodule mode: pinned source under shelf/moxi
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/davidmashburn/moxi.git --rev 57679a1d9099ec5843c52b5766a435994f70f41c moxi
```

## API surface

### src/moxi/accessibility.mojo

- `struct Semantics(ImplicitlyCopyable)`
- `struct AccessibilitySnapshot`

### src/moxi/alignment.mojo

- `struct AlignmentState(Component)`

### src/moxi/animation.mojo

- `struct Animation(ImplicitlyCopyable)`

### src/moxi/app.mojo

- `struct CounterState(Component)`

### src/moxi/app_runtime.mojo

- `struct App[ComponentType: Component & Deinitable]`

## Usage (from the README)

```mojo
from moxi import App, CounterState, Event, Rect

var app = App[CounterState](
    CounterState(),
    Rect(0.0, 0.0, 384.0, 184.0),
)

# After the window backend produces an Event:
if app.dispatch(event):
    app.render(renderer)

# The same root can be rebuilt after a window resize:
if app.resize(Rect(0.0, 0.0, width, height)):
    app.render(renderer)
```

---

# mozz_mlake (source tin on mojoshelf, git-pinned per published version)

Packaged build of mozz by Ehsan M. Kermani (github.com/ehsanmok/mozz) — pure-Mojo fuzzing and property-based testing: raw-byte fuzz(), typed forall[T]() with an Arbitrary trait, shrinking. Republished only because mozz is not on a conda channel; imported as `mozz`. Please send stars and issues upstream.

- package name (registry/conda): `mozz_mlake`
- Mojo import name: `mozz_mlake` (e.g. `from mozz_mlake import …`) — guessed from the tin name, verify in the repo
- author: winding-lines
- tags: mozz, fuzzing, property-based-testing, testing, quickcheck, redistribution, magmalake
- repository: https://github.com/magmalake/mozz_mlake.git
- latest version: 0.2.0 (commit c5eee7f5a420)
- activity: 0 stars, last push 2026-09-09T16:40:27Z, 0 commits last month / 37 last year

## Install

```sh
pixi shelf add mozz_mlake    # pixi mode: registry-pinned git source dependency
shelf add mozz_mlake         # submodule mode: pinned source under shelf/mozz_mlake
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/mozz_mlake.git --rev c5eee7f5a420f678a732bfb90c19d0a85a803758 mozz_mlake
```

---

# objectstore-mojo (source tin on mojoshelf, git-pinned per published version)

FileIO over local files, HTTP(S) range reads and S3 (SigV4, vended credentials, presigned URLs, multipart), with a libcurl-backed HTTP client and hardware-accelerated SHA-256

- package name (registry/conda): `objectstore-mojo`
- Mojo import name: `objectstore` (e.g. `from objectstore import …`)
- author: winding-lines
- tags: s3, http, objectstore, iceberg, sigv4, ffi, magmalake, sha256
- repository: https://github.com/magmalake/objectstore.mojo.git
- latest version: 0.3.1 (commit 31e7f6a38f31)
- depended on by: iceberg-mojo
- activity: 0 stars, last push 2026-09-04T02:15:21Z, 26 commits last month / 26 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:47Z)

## Install

```sh
pixi shelf add objectstore-mojo    # pixi mode: registry-pinned git source dependency
shelf add objectstore-mojo         # submodule mode: pinned source under shelf/objectstore-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/objectstore.mojo.git --rev 31e7f6a38f31891eba9de14a24848e7ccf7096be objectstore-mojo
```

## API surface

### src/objectstore/azure.mojo

- `struct AzureLocation(Copyable, Movable)`
- `struct AzureConfig(Copyable, Movable)`
- `struct BlobInfo(Copyable, Movable)`
- `struct AzureClient(Copyable, Movable)`

### src/objectstore/crypto.mojo

- `struct Sha256(Copyable, Movable)`

### src/objectstore/fileio.mojo

- `trait InputFile(Copyable, Movable)`
- `trait OutputFile(Copyable, Movable)`
- `trait FileIO(Copyable, Movable)`
- `struct AnyInputFile(Copyable, InputFile, Movable, RangeReader)`
- `struct AnyOutputFile(Copyable, Movable, OutputFile)`
- `struct StorageCredential(Copyable, Movable)`
- `struct FileIOResolver(Copyable, Movable)`

### src/objectstore/gcs.mojo

- `struct GcsConfig(Copyable, Movable)`
- `struct GcsClient(Copyable, Movable)`

## Usage (from the README)

```mojo
from objectstore import FileIOResolver

var io = FileIOResolver()
io.set("s3.region", "us-east-1")

var f = io.new_input("s3://warehouse/db/table/data/00000-1.parquet")
var footer = f.read_range(f.length() - 65536, 65536)   # just the footer
```

---

# offlinepoly (source tin on mojoshelf, git-pinned per published version)

Learning-free offline 3D multi-object tracking (Offline-Poly / Tracking-By-Tracking) for 4D auto-labeling

- package name (registry/conda): `offlinepoly`
- Mojo import name: `offlinepoly` (e.g. `from offlinepoly import …`)
- author: winding-lines
- tags: autolabeling, tracking, mot, lidar, offline
- repository: https://github.com/labelrefinery/OfflinePoly.mojo.git
- latest version: 0.1.0 (commit 1558c2efdd7e)
- activity: 0 stars, last push 2026-09-03T14:09:20Z, 4 commits last month / 4 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:01Z)

## Install

```sh
pixi shelf add offlinepoly    # pixi mode: registry-pinned git source dependency
shelf add offlinepoly         # submodule mode: pinned source under shelf/offlinepoly
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/labelrefinery/OfflinePoly.mojo.git --rev 1558c2efdd7e8928a598f0e96d7eb1aa0992a5d1 offlinepoly
```

## API surface

### src/offlinepoly/config.mojo

- `struct OfflinePolyConfig(Copyable, Movable)`

### src/offlinepoly/matching.mojo

- `struct Pair(ImplicitlyCopyable, Movable)`

## Usage (from the README)

```mojo
from offlinepoly import (
    OfflinePolyConfig, assign_frames, read_tracker_csv, run_pipeline,
)

def main() raises:
    var sources = [read_tracker_csv("fp_forward.csv"),
                   read_tracker_csv("fp_backward.csv")]
    var frame_times = assign_frames(sources)
    var refined = run_pipeline(
        sources, frame_times, OfflinePolyConfig(), ego_xy=[]
    )
```

---

# parquet-mojo (source tin on mojoshelf, git-pinned per published version)

Native pure-Mojo Apache Parquet reader and writer — every encoding, Arrow output over the C Data Interface

- package name (registry/conda): `parquet-mojo`
- Mojo import name: `parquet` (e.g. `from parquet import …`)
- author: winding-lines
- tags: parquet, arrow, iceberg, data-lake, columnar, magmalake
- repository: https://github.com/magmalake/parquet.mojo.git
- latest version: 0.8.0 (commit 3ebcd44e261d)
- depends on: hashes-mojo, snappy-mojo, zstd-mojo, lz4-mojo, thrift-mojo, avro-mojo, threads-mojo, brotli-mojo
- depended on by: iceberg-mojo
- activity: 0 stars, last push 2026-09-06T13:42:35Z, 87 commits last month / 87 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:48Z)

## Install

```sh
pixi shelf add parquet-mojo    # pixi mode: registry-pinned git source dependency
shelf add parquet-mojo         # submodule mode: pinned source under shelf/parquet-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/parquet.mojo.git --rev 3ebcd44e261d905be0cc0ceae058013eeecbfaf0 parquet-mojo
```

## API surface

### src/parquet/arrow.mojo

- `struct ArrowType(Copyable, Movable, Writable)`
- `struct ArrayData(Copyable, Movable)`
- `struct ArrayArena(Copyable, Defaultable, Movable)`

### src/parquet/assemble.mojo

- `struct LeafSlice(Copyable, Defaultable, Movable)`

### src/parquet/bitio.mojo

- `struct BitReader[origin: ImmOrigin](Copyable, Movable)`
- `struct HybridRuns[origin: ImmOrigin](Copyable, Movable)`
- `struct HybridDecoder[origin: ImmOrigin](Copyable, Movable)`

## Usage (from the README)

```mojo
from parquet import ParquetReader

var r = ParquetReader.open("part-0.parquet")
r.select_columns(["id", "name"])
var t = r.read_table()
print(t.num_rows, "rows,", t.num_columns(), "columns")

var ids = t.column_i64(0)        # (values, validity)
for i in range(len(ids[0])):
    if ids[1][i]:
        print(ids[0][i])
```

---

# pdftotext (source tin on mojoshelf, git-pinned per published version)

A from-scratch PDF-to-text extractor in Mojo

- package name (registry/conda): `pdftotext`
- Mojo import name: `pdf` (e.g. `from pdf import …`)
- author: winding-lines
- tags: pdf, documents, text-extraction
- repository: https://github.com/millfolio/pdftotext.mojo.git
- latest version: 0.1.3 (commit 7fb8c2c7ab53)
- depends on: zlib-mojo
- activity: 0 stars, last push 2026-09-06T13:38:03Z, 9 commits last month / 35 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:02Z)

## Install

```sh
pixi shelf add pdftotext    # pixi mode: registry-pinned git source dependency
shelf add pdftotext         # submodule mode: pinned source under shelf/pdftotext
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/pdftotext.mojo.git --rev 7fb8c2c7ab53eab860faf84688dc53b94ef09409 pdftotext
```

## API surface

### src/pdf/__init__.mojo

- `struct Buf(Movable)`
- `struct _Frag(Copyable, Movable)`
- `struct ObjMap(Movable)`
- `struct Font(Copyable, Movable)`
- `struct FontTable(Movable)`

## Usage (from the README)

```mojo
from pdf import read_file, extract_text
print(extract_text(read_file("doc.pdf")))
```

---

# pontoneer (source tin on mojoshelf, git-pinned per published version)

Mojo library providing additional type protocol extensions for Python interop

- package name (registry/conda): `pontoneer`
- Mojo import name: `pontoneer` (e.g. `from pontoneer import …`) — guessed from the tin name, verify in the repo
- author: winding-lines
- tags: python, interop, protocols
- repository: https://github.com/winding-lines/pontoneer.git
- latest version: 1.0.0 (commit 7e1599f94503)
- activity: 3 stars, last push 2026-09-01T12:35:56Z, 7 commits last month / 96 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:48Z)

## Install

```sh
pixi shelf add pontoneer    # pixi mode: registry-pinned git source dependency
shelf add pontoneer         # submodule mode: pinned source under shelf/pontoneer
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/winding-lines/pontoneer.git --rev 7e1599f945032c57dd4f677c1f6a280a95418122 pontoneer
```

---

# postgres-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo PostgreSQL client over libpq: parameterized queries, typed results, transactions, COPY, SQLSTATE errors, connection pooling

- package name (registry/conda): `postgres-mojo`
- Mojo import name: `postgres` (e.g. `from postgres import …`)
- author: winding-lines
- tags: postgres, postgresql, libpq, database, sql, ffi, pool, magmalake
- repository: https://github.com/magmalake/postgres.mojo
- latest version: 0.3.0 (commit 8e19bf4b471a)
- depends on: threads-mojo
- depended on by: iceberg-mojo
- activity: 0 stars, last push 2026-09-05T20:29:11Z, 17 commits last month / 20 last year

## Install

```sh
pixi shelf add postgres-mojo    # pixi mode: registry-pinned git source dependency
shelf add postgres-mojo         # submodule mode: pinned source under shelf/postgres-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/postgres.mojo --rev 8e19bf4b471a67b78a9f6503c955d3ea221b3a0a postgres-mojo
```

## API surface

### src/postgres/_ffi.mojo

- `struct LibpqFFI(Movable)`
- `struct _ParamArrays(Movable)`

### src/postgres/config.mojo

- `struct ConnectionConfig(Copyable, Movable)`

### src/postgres/connection.mojo

- `struct _Bound(Movable)`
- `struct _ConnCell(Movable)`
- `struct Statement(Movable)`
- `struct Connection(Movable)`
- `struct Transaction(Movable)`

### src/postgres/copy.mojo

- `struct CopyIn(Movable)`
- `struct CopyOut(Movable)`

### src/postgres/copyfmt.mojo

- `struct CopyEncoder(Movable)`
- `struct CopyDecoder(Movable)`

## Usage (from the README)

```mojo
    # By column name...
    var res = conn.query("SELECT id, name, note FROM qb_people ORDER BY id")
    for row in res:
        var note = "NULL" if row.is_null("note") else row.text("note")
        print(row.int64("id"), row.text("name"), note)

    # ... and by 0-based index, which works the same on a `Row` obtained
    # either way -- both ways resolve through the same column metadata.
    var first = res.row(0)
    print("by index:", first.int64(0), first.text(1))
```

---

# raylib_mojo (source tin on mojoshelf, git-pinned per published version)

Mojo bindings for raylib, a simple and easy-to-use library to enjoy videogames programming

- package name (registry/conda): `raylib_mojo`
- Mojo import name: `raylib_mojo` (e.g. `from raylib_mojo import …`) — guessed from the tin name, verify in the repo
- author: willGuimont
- tags: raylib, graphics, gamedev, bindings
- repository: https://github.com/willGuimont/raylib_mojo.git
- latest version: 0.1.1 (commit 7f3ee921c459)
- activity: 1 stars, last push 2026-09-02T15:29:44Z, 17 commits last month / 17 last year

## Install

```sh
pixi shelf add raylib_mojo    # pixi mode: registry-pinned git source dependency
shelf add raylib_mojo         # submodule mode: pinned source under shelf/raylib_mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/willGuimont/raylib_mojo.git --rev 7f3ee921c4597f9b84bafc8d857843b3a65dd577 raylib_mojo
```

## Usage (from the README)

```mojo
from raylib import (
    init_window, window_should_close, close_window, set_target_fps,
    begin_drawing, end_drawing, clear_background, draw_text, draw_fps,
    RAYWHITE, DARKGRAY, LIGHTGRAY, MAROON
)
from raylib.gui import Gui, GuiCheckBox, GuiSlider, Rectangle

def main():
    # Initialize window
    init_window(800, 450, "raylib + raygui [core] example")
    set_target_fps(60)

    var chk = GuiCheckBox(Rectangle(30, 80, 20, 20), "Enable Feature", True)
    var slider = GuiSlider(Rectangle(30, 120, 150, 20), "Speed", "100%", 0.5, 0.0, 1.0)

    # Main game loop
    while not window_should_close():
        begin_drawing()
        clear_background(RAYWHITE())

        draw_text("Congrats! You created your first raylib + raygui mojo window!", 120, 30, 20, DARKGRAY())
        
        # Draw raygui controls
        _ = chk.draw()
        _ = slider.draw()
        if Gui.button(Rectangle(30, 160, 150, 30), "Click Me"):
            print("Button clicked!")

        draw_fps(10, 10)
        end_drawing()
```

---

# restate-mojo (source tin on mojoshelf, git-pinned per published version)

Durable execution flows in Mojo via Restate: Rust SDK event loop and journal behind a C-ABI shim, business logic in Mojo, served on one thread or N

- package name (registry/conda): `restate-mojo`
- Mojo import name: `restate` (e.g. `from restate import …`)
- author: winding-lines
- tags: durable-execution, workflows, restate, ffi, concurrency
- repository: https://github.com/magmalake/restate.mojo.git
- latest version: 0.3.2 (commit e01fda13dbe4)
- depends on: threads-mojo
- activity: 0 stars, last push 2026-09-03T22:57:50Z, 22 commits last month / 22 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:49Z)

## Install

```sh
pixi shelf add restate-mojo    # pixi mode: registry-pinned git source dependency
shelf add restate-mojo         # submodule mode: pinned source under shelf/restate-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/restate.mojo.git --rev e01fda13dbe4d4cf00988a578f5713d70045dd6a restate-mojo
```

## API surface

### src/restate/__init__.mojo

- `struct Invocation(Copyable, Movable)`
- `struct App(Movable)`
- `struct Unit(Copyable, Movable)`
- `struct Ctx[T: AnyType](Copyable, Movable)`
- `struct _Serve[app_origin: ImmOrigin](Movable)`

## Usage (from the README)

```mojo
from restate import App, Ctx, Invocation, Unit

def handle_add(app: App, inv: Invocation, worker: Int, ctx: Ctx[Unit]) raises:
    var n = app.get_state_int(inv, "count", 0) + 1
    app.set_state_int(inv, "count", n)
    app.complete(inv, String(n))

def handle_get(app: App, inv: Invocation, worker: Int, ctx: Ctx[Unit]) raises:
    app.complete(inv, String(app.get_state_int(inv, "count", 0)))

def main() raises:
    var nothing = Unit()
    _ = App.run[Unit, __functions_in_module()]("Counter", nothing)
```

---

# roaring-mojo (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo Roaring bitmaps (32-bit and 64-bit) with portable serialization and Apache Iceberg deletion-vector framing

- package name (registry/conda): `roaring-mojo`
- Mojo import name: `roaring` (e.g. `from roaring import …`)
- author: winding-lines
- tags: roaring, bitmap, iceberg, data-lake, serialization
- repository: https://github.com/magmalake/roaring.mojo.git
- latest version: 0.1.1 (commit 3bc237cd6bd1)
- depended on by: iceberg-mojo
- activity: 0 stars, last push 2026-09-05T12:46:11Z, 20 commits last month / 20 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:49Z)

## Install

```sh
pixi shelf add roaring-mojo    # pixi mode: registry-pinned git source dependency
shelf add roaring-mojo         # submodule mode: pinned source under shelf/roaring-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/roaring.mojo.git --rev 3bc237cd6bd1a6dd87bf34aa27b1cb9780f7026f roaring-mojo
```

## API surface

### src/roaring/bitmap32.mojo

- `struct Bitmap32(Copyable, Movable)`

### src/roaring/bitmap64.mojo

- `struct Bitmap64(Copyable, Movable)`

### src/roaring/container.mojo

- `struct Container(Copyable, Movable)`

## Usage (from the README)

```mojo
4 bytes   length of (magic + vector), BIG-ENDIAN
4 bytes   magic: D1 D3 39 64
N bytes   the 64-bit portable Roaring vector (LITTLE-ENDIAN internally)
4 bytes   CRC-32 (standard, as in gzip/zlib) over (magic + vector), BIG-ENDIAN
```

---

# snappy-mojo (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo Snappy compressor/decompressor (raw block format + framing format)

- package name (registry/conda): `snappy-mojo`
- Mojo import name: `snappy` (e.g. `from snappy import …`)
- author: winding-lines
- tags: snappy, compression, parquet, avro, codec
- repository: https://github.com/magmalake/snappy.mojo.git
- latest version: 0.1.2 (commit 33cad1faf042)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-05T12:45:48Z, 21 commits last month / 21 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:49Z)

## Install

```sh
pixi shelf add snappy-mojo    # pixi mode: registry-pinned git source dependency
shelf add snappy-mojo         # submodule mode: pinned source under shelf/snappy-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/snappy.mojo.git --rev 33cad1faf0427543ed0142bbf1ffe7e41833a62a snappy-mojo
```

## API surface

### src/snappy/crc32c.mojo

- `struct Crc32c(Copyable, Movable)`

### src/snappy/framing.mojo

- `struct FramedWriter(Movable)`
- `struct FramedReader(Movable)`

## Usage (from the README)

```mojo
from snappy import compress, decompress

var packed = compress(Span(data))       # List[UInt8]
var back = decompress(Span(packed))     # List[UInt8], == data

from snappy import compress_framed, decompress_framed

var stream = compress_framed(Span(data))    # sNaPpY-framed, CRC-32C per chunk
var back2 = decompress_framed(Span(stream)) # verifies every chunk's checksum
```

---

# sqlite-mojo (source tin on mojoshelf, git-pinned per published version)

SQLite bindings for Mojo via FFI: connections, prepared statements, RAII transactions

- package name (registry/conda): `sqlite-mojo`
- Mojo import name: `sqlite` (e.g. `from sqlite import …`)
- author: winding-lines
- tags: sqlite, database, sql, ffi, magmalake, iceberg, catalog
- repository: https://github.com/magmalake/sqlite.mojo.git
- latest version: 0.3.2 (commit 2364a6e89527)
- depended on by: iceberg-mojo
- activity: 0 stars, last push 2026-09-04T02:15:42Z, 17 commits last month / 49 last year

## Install

```sh
pixi shelf add sqlite-mojo    # pixi mode: registry-pinned git source dependency
shelf add sqlite-mojo         # submodule mode: pinned source under shelf/sqlite-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/sqlite.mojo.git --rev 2364a6e895277e8520b60e5666a0491bd7871bb1 sqlite-mojo
```

## Usage (from the README)

```mojo
from sqlite import Database

def main() raises:
    var db = Database(":memory:")          # or a file path
    db.execute("CREATE TABLE t (id INTEGER, label TEXT)")

    var stmt = db.prepare("INSERT INTO t VALUES (?, ?)")
    stmt.bind_int(1, 42)                   # parameters are 1-based
    stmt.bind_text(2, "hello")
    _ = stmt.step()

    var q = db.prepare("SELECT id, label FROM t")
    while True:
        var row = q.step()                 # Optional[Row]; None when exhausted
        if not row:
            break
        ref r = row.value()
        print(r.int_val(0), r.text_val(1))  # columns are 0-based
        # 42 hello
```

---

# stone-mojo (source tin on mojoshelf, git-pinned per published version)

- package name (registry/conda): `stone-mojo`
- Mojo import name: `stone` (e.g. `from stone import …`)
- author: winding-lines
- repository: https://github.com/labelrefinery/Stone.mojo.git
- latest version: 0.1.0 (commit 9a37fac97fc8)
- activity: 0 stars, last push 2026-08-29T12:25:44Z, 6 commits last month / 6 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:03Z)

## Install

```sh
pixi shelf add stone-mojo    # pixi mode: registry-pinned git source dependency
shelf add stone-mojo         # submodule mode: pinned source under shelf/stone-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/labelrefinery/Stone.mojo.git --rev 9a37fac97fc80313941796cf0b2cc3d824e93cf5 stone-mojo
```

## API surface

### src/stone/__init__.mojo

- `struct Vec3(ImplicitlyCopyable, Movable)`
- `struct GridSpec(ImplicitlyCopyable, Movable)`
- `struct CellAccumulator(ImplicitlyCopyable, Movable)`
- `struct Sym3(ImplicitlyCopyable, Movable)`
- `struct Eigen3(Movable)`
- `struct TerrainCell(ImplicitlyCopyable, Movable)`
- `struct CellFeatures(ImplicitlyCopyable, Movable)`
- `struct TerrainGrid(Movable)`
- `struct TraversabilityModel(Movable)`
- `struct StoneLabels(Movable)`

## Usage (from the README)

```mojo
from stone import GridSpec, TerrainGrid, TraversabilityModel
```

---

# threads-mojo (source tin on mojoshelf, git-pinned per published version)

Minimal pthreads for Mojo: spawn/join, atomics, a mutex, parallel_for, and a WorkerPool (typed or untyped)

- package name (registry/conda): `threads-mojo`
- Mojo import name: `threads` (e.g. `from threads import …`)
- author: winding-lines
- tags: magmalake, threads, pthreads, concurrency, parallel, atomics, worker-pool
- repository: https://github.com/magmalake/threads.mojo.git
- latest version: 0.4.0 (commit 772dd842d422)
- depended on by: iceberg-mojo, restate-mojo
- activity: 0 stars, last push 2026-09-03T17:05:12Z, 12 commits last month / 12 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:03Z)

## Install

```sh
pixi shelf add threads-mojo    # pixi mode: registry-pinned git source dependency
shelf add threads-mojo         # submodule mode: pinned source under shelf/threads-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/threads.mojo.git --rev 772dd842d4222aeae48e4eda9766ff2edec1bdff threads-mojo
```

## API surface

### src/threads/atomic.mojo

- `struct AtomicCounter(Copyable, ImplicitlyCopyable, Movable)`
- `struct AtomicFlag(Copyable, ImplicitlyCopyable, Movable)`

### src/threads/mutex.mojo

- `struct MutexRef(Copyable, ImplicitlyCopyable, Movable)`
- `struct Mutex(Movable)`
- `struct CondVarRef(Copyable, ImplicitlyCopyable, Movable)`
- `struct CondVar(Movable)`

### src/threads/parallel.mojo

- `struct Totals(Copyable, Movable)`
- `struct ThreadGroup(Movable, Sized)`

## Usage (from the README)

```mojo
from threads import AtomicCounter, parallel_for


@fieldwise_init
struct Totals(Copyable, Movable):
    var sum: Int64


def task(i: Int, mut totals: Totals) -> None:
    _ = AtomicCounter.at(Int(Pointer(to=totals.sum))).fetch_add(Int64(i))


def main() raises:
    var totals = Totals(0)
    parallel_for[task](1000, totals)
    print(totals.sum)   # 499500
```

---

# thrift-mojo (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo Apache Thrift serialization — TCompactProtocol, TBinaryProtocol, and the Parquet metadata structs

- package name (registry/conda): `thrift-mojo`
- Mojo import name: `thrift` (e.g. `from thrift import …`)
- author: winding-lines
- tags: thrift, parquet, iceberg, data-lake, serialization
- repository: https://github.com/magmalake/thrift.mojo.git
- latest version: 0.1.1 (commit f4c3bdddd0c0)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-05T18:03:47Z, 25 commits last month / 25 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:50Z)

## Install

```sh
pixi shelf add thrift-mojo    # pixi mode: registry-pinned git source dependency
shelf add thrift-mojo         # submodule mode: pinned source under shelf/thrift-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/thrift.mojo.git --rev f4c3bdddd0c06bbad0c49c2b05c7afc30e7aa67a thrift-mojo
```

## API surface

### src/thrift/parquet_types.mojo

- `struct Type(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct ConvertedType(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct FieldRepetitionType(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct EdgeInterpolationAlgorithm(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct Encoding(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct CompressionCodec(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct PageType(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct BoundaryOrder(Copyable, Defaultable, Equatable, ImplicitlyCopyable, Movable, Writable)`
- `struct SizeStatistics(Copyable, Defaultable, Movable)`
- `struct BoundingBox(Copyable, Defaultable, Movable)`
- `struct GeospatialStatistics(Copyable, Defaultable, Movable)`
- `struct Statistics(Copyable, Defaultable, Movable)`
- `struct StringType(Copyable, Defaultable, Movable)`
- `struct UUIDType(Copyable, Defaultable, Movable)`
- `struct MapType(Copyable, Defaultable, Movable)`
- `struct ListType(Copyable, Defaultable, Movable)`
- `struct EnumType(Copyable, Defaultable, Movable)`
- `struct DateType(Copyable, Defaultable, Movable)`
- `struct Float16Type(Copyable, Defaultable, Movable)`
- `struct NullType(Copyable, Defaultable, Movable)`

### src/thrift/protocol.mojo

- `trait TProtocolReader`
- `trait TProtocolWriter`
- `struct TCompactProtocolReader[origin: ImmOrigin](`
- `struct TCompactProtocolWriter(Copyable, Movable, Defaultable, Sized, TProtocolWriter)`
- `struct TBinaryProtocolReader[origin: ImmOrigin](`
- `struct TBinaryProtocolWriter(Copyable, Movable, Defaultable, Sized, TProtocolWriter)`

## Usage (from the README)

```mojo
from thrift import read_footer, read_parquet_file

var bytes = read_parquet_file("part-0.parquet")
var meta = read_footer(Span(bytes))
print(meta.num_rows, "rows in", len(meta.row_groups), "row groups")
for rg in meta.row_groups:
    for cc in rg.columns:
        ref cm = cc.meta_data.value()
        print(cm.path_in_schema[0], cm.codec.name(), cm.num_values)
```

---

# trackpermanence (source tin on mojoshelf, git-pinned per published version)

Pure-Mojo inference for Offline Tracking with Object Permanence: tracklet Re-ID across occlusions + occluded-pose completion (arXiv:2310.01288)

- package name (registry/conda): `trackpermanence`
- Mojo import name: `trackpermanence` (e.g. `from trackpermanence import …`)
- author: winding-lines
- tags: autolabeling, tracking, occlusion, gru, inference
- repository: https://github.com/labelrefinery/TrackPermanence.mojo.git
- latest version: 0.1.0 (commit 72f2d512732e)
- activity: 0 stars, last push 2026-09-03T14:09:24Z, 4 commits last month / 4 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:03Z)

## Install

```sh
pixi shelf add trackpermanence    # pixi mode: registry-pinned git source dependency
shelf add trackpermanence         # submodule mode: pinned source under shelf/trackpermanence
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/labelrefinery/TrackPermanence.mojo.git --rev 72f2d512732ee3ce1f9098d58e73573f4b3496a6 trackpermanence
```

## API surface

### src/trackpermanence/features.mojo

- `struct LocalFrame(Copyable, Movable)`

---

# zlib-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo zlib binding (inflate/deflate) via FFI to libz

- package name (registry/conda): `zlib-mojo`
- Mojo import name: `zlib` (e.g. `from zlib import …`)
- author: winding-lines
- tags: compression, zlib, ffi
- repository: https://github.com/millfolio/zlib.mojo.git
- latest version: 0.1.2 (commit f243ffab8dd7)
- depended on by: docx, pdftotext
- activity: 0 stars, last push 2026-08-29T12:08:30Z, 6 commits last month / 24 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-08-31T14:12:03Z)

## Install

```sh
pixi shelf add zlib-mojo    # pixi mode: registry-pinned git source dependency
shelf add zlib-mojo         # submodule mode: pinned source under shelf/zlib-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/millfolio/zlib.mojo.git --rev f243ffab8dd7a84bce07eeced59053cc7a315e3d zlib-mojo
```

## Usage (from the README)

```mojo
from zlib import inflate, deflate

var raw = inflate(compressed)   # List[UInt8] -> List[UInt8]  (zlib or raw deflate)
var z   = deflate(raw)          # round-trip partner
```

---

# zstd-mojo (source tin on mojoshelf, git-pinned per published version)

A Mojo binding to libzstd (one-shot and streaming compress/decompress) via FFI

- package name (registry/conda): `zstd-mojo`
- Mojo import name: `zstd` (e.g. `from zstd import …`)
- author: winding-lines
- tags: compression, zstd, ffi, parquet, iceberg, avro
- repository: https://github.com/magmalake/zstd.mojo.git
- latest version: 0.1.2 (commit 208870011133)
- depended on by: iceberg-mojo, parquet-mojo
- activity: 0 stars, last push 2026-09-05T12:48:02Z, 18 commits last month / 18 last year
- verified: consumer smoke build passed with mojo-compiler 1.0.0 (checked 2026-09-07T12:52:50Z)

## Install

```sh
pixi shelf add zstd-mojo    # pixi mode: registry-pinned git source dependency
shelf add zstd-mojo         # submodule mode: pinned source under shelf/zstd-mojo
```

Or with plain pixi (no shelf CLI):
```sh
pixi add --git https://github.com/magmalake/zstd.mojo.git --rev 2088700111339559978ea592c56eb55e75757346 zstd-mojo
```

## API surface

### src/zstd/__init__.mojo

- `struct Compressor(Movable)`
- `struct Decompressor(Movable)`

## Usage (from the README)

```mojo
from zstd import compress, decompress

var z   = compress(raw)          # Span[UInt8] -> List[UInt8], level 1..22 (default 3)
var raw2 = decompress(z)         # -> List[UInt8], byte-for-byte back

var n = decompress_into(z, dst)  # write straight into a caller-owned buffer
                                  # (e.g. a Parquet page's declared size) —
                                  # no growth, no extra allocation

is_zstd_frame(z)                 # Bool — magic-number sniff, no allocation
frame_content_size(z)            # Optional[Int] — decompressed size from
                                  # the frame header, if it carries one
```

---

# argmojo (binary package from the modular-community channel, mirrored on mojoshelf)

A feature-rich command-line argument parser library for Mojo, with both builder and struct-based declarative APIs.

- package name (registry/conda): `argmojo`
- Mojo import name: `argmojo` (e.g. `from argmojo import …`) — guessed from the tin name, verify in the repo
- author: forfudan
- repository: https://github.com/forfudan/argmojo
- latest channel version: 0.8.0
- activity: 19 stars, last push 2026-08-12T18:47:07Z, 1 commits last month / 75 last year

## Install

```sh
pixi shelf add argmojo    # or plain: pixi add argmojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# bridge (binary package from the modular-community channel, mirrored on mojoshelf)

Convert (bridge) Python objects to Mojo and vice versa.

- package name (registry/conda): `bridge`
- Mojo import name: `bridge` (e.g. `from bridge import …`) — guessed from the tin name, verify in the repo
- author: hylkedonker
- repository: https://gitlab.com/hylkedonker/bridge
- latest channel version: 1.0.0

## Install

```sh
pixi shelf add bridge    # or plain: pixi add bridge
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# crypto (binary package from the modular-community channel, mirrored on mojoshelf)

A Mojo cryptography library intended to cover the commonly used cryptographic algorithms.

- package name (registry/conda): `crypto`
- Mojo import name: `crypto` (e.g. `from crypto import …`) — guessed from the tin name, verify in the repo
- author: lczerniawski
- repository: https://github.com/lczerniawski/crypto
- latest channel version: 0.2.0
- activity: 2 stars, last push 2026-08-12T15:56:14Z, 2 commits last month / 17 last year

## Install

```sh
pixi shelf add crypto    # or plain: pixi add crypto
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# decimo (binary package from the modular-community channel, mirrored on mojoshelf)

An arbitrary-precision integer and decimal library for Mojo, also with a 128-bit fixed-point decimal type.

- package name (registry/conda): `decimo`
- Mojo import name: `decimo` (e.g. `from decimo import …`) — guessed from the tin name, verify in the repo
- author: forfudan
- repository: https://github.com/forfudan/decimo
- latest channel version: 0.14.0
- activity: 29 stars, last push 2026-09-04T21:07:12Z, 71 commits last month / 214 last year

## Install

```sh
pixi shelf add decimo    # or plain: pixi add decimo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# decimojo (binary package from the modular-community channel, mirrored on mojoshelf)

- package name (registry/conda): `decimojo`
- Mojo import name: `decimojo` (e.g. `from decimojo import …`) — guessed from the tin name, verify in the repo
- repository: https://prefix.dev/channels/modular-community/packages/decimojo
- latest channel version: 0.7.0

## Install

```sh
pixi shelf add decimojo    # or plain: pixi add decimojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# emberjson (binary package from the modular-community channel, mirrored on mojoshelf)

A lightweight JSON parsing library written in pure Mojo

- package name (registry/conda): `emberjson`
- Mojo import name: `emberjson` (e.g. `from emberjson import …`) — guessed from the tin name, verify in the repo
- author: bgreni
- repository: https://github.com/bgreni/EmberJson
- latest channel version: 0.3.4
- activity: 63 stars, last push 2026-09-03T03:18:50Z, 46 commits last month / 182 last year

## Install

```sh
pixi shelf add emberjson    # or plain: pixi add emberjson
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# endia (binary package from the modular-community channel, mirrored on mojoshelf)

- package name (registry/conda): `endia`
- Mojo import name: `endia` (e.g. `from endia import …`) — guessed from the tin name, verify in the repo
- repository: https://prefix.dev/channels/modular-community/packages/endia
- latest channel version: 24.6.0

## Install

```sh
pixi shelf add endia    # or plain: pixi add endia
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# extramojo (binary package from the modular-community channel, mirrored on mojoshelf)

Extra functionality not yet in the standard library, mostly focused on strings and file IO.

- package name (registry/conda): `extramojo`
- Mojo import name: `extramojo` (e.g. `from extramojo import …`) — guessed from the tin name, verify in the repo
- author: sstadick
- repository: https://github.com/ExtraMojo/ExtraMojo
- latest channel version: 0.23.0
- activity: 15 stars, last push 2026-09-04T21:31:59Z, 5 commits last month / 54 last year

## Install

```sh
pixi shelf add extramojo    # or plain: pixi add extramojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# heat-url (binary package from the modular-community channel, mirrored on mojoshelf)

URI and URL parsing for Mojo (WHATWG and RFC 3986), with native IDNA.

- package name (registry/conda): `heat-url`
- Mojo import name: `heat_url` (e.g. `from heat_url import …`) — guessed from the tin name, verify in the repo
- author: joeressler
- repository: https://github.com/joeressler/heat-url
- latest channel version: 1.0.0
- activity: 1 stars, last push 2026-08-21T14:00:13Z, 29 commits last month / 29 last year

## Install

```sh
pixi shelf add heat-url    # or plain: pixi add heat-url
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# hue (binary package from the modular-community channel, mirrored on mojoshelf)

- package name (registry/conda): `hue`
- Mojo import name: `hue` (e.g. `from hue import …`) — guessed from the tin name, verify in the repo
- repository: https://prefix.dev/channels/modular-community/packages/hue
- latest channel version: 0.0.1

## Install

```sh
pixi shelf add hue    # or plain: pixi add hue
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# infrared (binary package from the modular-community channel, mirrored on mojoshelf)

A geometric algebra library for mojo.

- package name (registry/conda): `infrared`
- Mojo import name: `infrared` (e.g. `from infrared import …`) — guessed from the tin name, verify in the repo
- author: helehex
- repository: https://github.com/helehex/infrared
- latest channel version: 0.1.0
- activity: 25 stars, last push 2026-08-06T17:50:23Z, 0 commits last month / 17 last year

## Install

```sh
pixi shelf add infrared    # or plain: pixi add infrared
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# ish (binary package from the modular-community channel, mirrored on mojoshelf)

Alignment-based filtering CLI tool

- package name (registry/conda): `ish`
- Mojo import name: `ish` (e.g. `from ish import …`) — guessed from the tin name, verify in the repo
- author: sstadick
- repository: https://github.com/BioRadOpenSource/ish
- latest channel version: 1.4.0
- activity: 62 stars, last push 2025-10-31T19:00:13Z, 0 commits last month / 2 last year

## Install

```sh
pixi shelf add ish    # or plain: pixi add ish
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# kelvin (binary package from the modular-community channel, mirrored on mojoshelf)

A powerful dimensional analysis library written in Mojo

- package name (registry/conda): `kelvin`
- Mojo import name: `kelvin` (e.g. `from kelvin import …`) — guessed from the tin name, verify in the repo
- author: bgreni
- repository: https://github.com/bgreni/Kelvin
- latest channel version: 0.3.0
- activity: 16 stars, last push 2026-08-14T04:17:10Z, 0 commits last month / 43 last year

## Install

```sh
pixi shelf add kelvin    # or plain: pixi add kelvin
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# lambda_runtime (binary package from the modular-community channel, mirrored on mojoshelf)

AWS Lambda custom runtime library for Mojo (provided.al2023 / arm64)

- package name (registry/conda): `lambda_runtime`
- Mojo import name: `lambda_runtime` (e.g. `from lambda_runtime import …`) — guessed from the tin name, verify in the repo
- author: fourlexboehm
- repository: https://github.com/fourlexboehm/mojo-lambda-runtime
- latest channel version: 0.1.0
- activity: 0 stars, last push 2026-07-17T08:03:09Z, 0 commits last month / 6 last year

## Install

```sh
pixi shelf add lambda_runtime    # or plain: pixi add lambda_runtime
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# libc (binary package from the modular-community channel, mirrored on mojoshelf)

Mojo's libc support

- package name (registry/conda): `libc`
- Mojo import name: `libc` (e.g. `from libc import …`) — guessed from the tin name, verify in the repo
- author: msaelices
- repository: https://github.com/msaelices/mojo-libc
- latest channel version: 0.1.9
- activity: 4 stars, last push 2025-02-08T22:37:09Z, 0 commits last month / 0 last year

## Install

```sh
pixi shelf add libc    # or plain: pixi add libc
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# libclang_mojo (binary package from the modular-community channel, mirrored on mojoshelf)

High-level Mojo bindings for LLVM libclang

- package name (registry/conda): `libclang_mojo`
- Mojo import name: `libclang_mojo` (e.g. `from libclang_mojo import …`) — guessed from the tin name, verify in the repo
- author: MoSafi2
- repository: https://github.com/MoSafi2/mojo_libclang
- latest channel version: 0.1.0
- activity: 0 stars, last push 2026-06-24T14:51:31Z, 0 commits last month / 149 last year

## Install

```sh
pixi shelf add libclang_mojo    # or plain: pixi add libclang_mojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# lightbug_http (binary package from the modular-community channel, mirrored on mojoshelf)

Lightbug is a simple and sweet HTTP framework for Mojo

- package name (registry/conda): `lightbug_http`
- Mojo import name: `lightbug_http` (e.g. `from lightbug_http import …`) — guessed from the tin name, verify in the repo
- author: saviorand
- repository: https://github.com/saviorand/lightbug_http
- latest channel version: 25.4.0
- activity: 736 stars, last push 2026-05-12T18:19:17Z, 0 commits last month / 178 last year

## Install

```sh
pixi shelf add lightbug_http    # or plain: pixi add lightbug_http
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# linamo (binary package from the modular-community channel, mirrored on mojoshelf)

Linear algebra for Mojo, specialized for two-dimensional matrices.

- package name (registry/conda): `linamo`
- Mojo import name: `linamo` (e.g. `from linamo import …`) — guessed from the tin name, verify in the repo
- author: forfudan
- repository: https://github.com/mojomath/linamo
- latest channel version: 0.1.0
- activity: 4 stars, last push 2026-09-01T14:17:30Z, 25 commits last month / 43 last year

## Install

```sh
pixi shelf add linamo    # or plain: pixi add linamo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mav (binary package from the modular-community channel, mirrored on mojoshelf)

MAV (Mojo Audio Video) is a FFmpeg binding library for Mojo.

- package name (registry/conda): `mav`
- Mojo import name: `mav` (e.g. `from mav import …`) — guessed from the tin name, verify in the repo
- author: josiahls
- repository: https://github.com/josiahls/mav
- latest channel version: 0.0.4
- activity: 1 stars, last push 2026-04-27T17:50:56Z, 0 commits last month / 40 last year

## Install

```sh
pixi shelf add mav    # or plain: pixi add mav
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mimage (binary package from the modular-community channel, mirrored on mojoshelf)

mimage is a library for image processing in Mojo 🔥.

- package name (registry/conda): `mimage`
- Mojo import name: `mimage` (e.g. `from mimage import …`) — guessed from the tin name, verify in the repo
- author: fnands
- repository: https://github.com/fnands/mimage
- latest channel version: 0.2.3
- activity: 21 stars, last push 2025-04-14T09:17:56Z, 0 commits last month / 0 last year

## Install

```sh
pixi shelf add mimage    # or plain: pixi add mimage
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mist (binary package from the modular-community channel, mirrored on mojoshelf)

Mist lets you safely use advanced styling options on the terminal.

- package name (registry/conda): `mist`
- Mojo import name: `mist` (e.g. `from mist import …`) — guessed from the tin name, verify in the repo
- author: thatstoasty
- repository: https://github.com/thatstoasty/mist
- latest channel version: 26.2.0
- activity: 23 stars, last push 2026-08-29T14:08:52Z, 5 commits last month / 43 last year

## Install

```sh
pixi shelf add mist    # or plain: pixi add mist
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mogo-tester (binary package from the modular-community channel, mirrored on mojoshelf)

Compile and run top-level Mojo test files.

- package name (registry/conda): `mogo-tester`
- Mojo import name: `mogo_tester` (e.g. `from mogo_tester import …`) — guessed from the tin name, verify in the repo
- author: moseschmiedel
- repository: https://github.com/moseschmiedel/mogo_tester
- latest channel version: 2.3.1
- activity: 2 stars, last push 2026-06-25T09:19:08Z, 0 commits last month / 28 last year

## Install

```sh
pixi shelf add mogo-tester    # or plain: pixi add mogo-tester
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojmelo (binary package from the modular-community channel, mirrored on mojoshelf)

Machine Learning algorithms in pure Mojo.

- package name (registry/conda): `mojmelo`
- Mojo import name: `mojmelo` (e.g. `from mojmelo import …`) — guessed from the tin name, verify in the repo
- author: yetalit
- repository: https://github.com/yetalit/Mojmelo
- latest channel version: 0.1.5
- activity: 78 stars, last push 2026-09-07T15:27:03Z, 16 commits last month / 215 last year

## Install

```sh
pixi shelf add mojmelo    # or plain: pixi add mojmelo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-dotenv (binary package from the modular-community channel, mirrored on mojoshelf)

Load environment variables from .env files in Mojo

- package name (registry/conda): `mojo-dotenv`
- Mojo import name: `dotenv` (e.g. `from dotenv import …`) — guessed from the tin name, verify in the repo
- author: DataBooth
- repository: https://github.com/DataBooth/mojo-dotenv
- latest channel version: 0.2.2
- activity: 5 stars, last push 2026-08-16T09:00:40Z, 2 commits last month / 53 last year

## Install

```sh
pixi shelf add mojo-dotenv    # or plain: pixi add mojo-dotenv
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-ini (binary package from the modular-community channel, mirrored on mojoshelf)

Simple INI file parser for Mojo

- package name (registry/conda): `mojo-ini`
- Mojo import name: `ini` (e.g. `from ini import …`) — guessed from the tin name, verify in the repo
- author: Hammad-hab
- repository: https://github.com/Hammad-hab/MojoINI
- latest channel version: 0.1.0
- activity: 2 stars, last push 2025-07-12T09:58:43Z, 0 commits last month / 0 last year

## Install

```sh
pixi shelf add mojo-ini    # or plain: pixi add mojo-ini
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-intel-gpu (binary package from the modular-community channel, mirrored on mojoshelf)

Level Zero FFI bindings and high-level API for Intel GPU compute in Mojo

- package name (registry/conda): `mojo-intel-gpu`
- Mojo import name: `intel_gpu` (e.g. `from intel_gpu import …`) — guessed from the tin name, verify in the repo
- author: andomeder
- repository: https://github.com/andomeder/mojo-intel-gpu
- latest channel version: 0.2.0
- activity: 7 stars, last push 2026-08-14T21:44:43Z, 5 commits last month / 23 last year

## Install

```sh
pixi shelf add mojo-intel-gpu    # or plain: pixi add mojo-intel-gpu
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-net (binary package from the modular-community channel, mirrored on mojoshelf)

TCP, UDP, DNS, Unix sockets, and readiness polling for Mojo

- package name (registry/conda): `mojo-net`
- Mojo import name: `net` (e.g. `from net import …`) — guessed from the tin name, verify in the repo
- author: nsalerni
- repository: https://github.com/nsalerni/mojo-net
- latest channel version: 0.2.6
- activity: 0 stars, last push 2026-09-06T03:48:40Z, 66 commits last month / 66 last year

## Install

```sh
pixi shelf add mojo-net    # or plain: pixi add mojo-net
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-regex (binary package from the modular-community channel, mirrored on mojoshelf)

Library for dealing with regular expressions in Mojo

- package name (registry/conda): `mojo-regex`
- Mojo import name: `regex` (e.g. `from regex import …`) — guessed from the tin name, verify in the repo
- author: msaelices
- repository: https://github.com/msaelices/mojo-regex
- latest channel version: 0.21.0
- activity: 16 stars, last push 2026-09-01T08:16:47Z, 12 commits last month / 393 last year

## Install

```sh
pixi shelf add mojo-regex    # or plain: pixi add mojo-regex
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-toml (binary package from the modular-community channel, mirrored on mojoshelf)

- package name (registry/conda): `mojo-toml`
- Mojo import name: `toml` (e.g. `from toml import …`) — guessed from the tin name, verify in the repo
- repository: https://prefix.dev/channels/modular-community/packages/mojo-toml
- latest channel version: 0.5.1

## Install

```sh
pixi shelf add mojo-toml    # or plain: pixi add mojo-toml
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-window (binary package from the modular-community channel, mirrored on mojoshelf)

SDL3-based windowing library for Mojo

- package name (registry/conda): `mojo-window`
- Mojo import name: `window` (e.g. `from window import …`) — guessed from the tin name, verify in the repo
- author: Maelkiz
- repository: https://github.com/Maelkiz/mojo-window
- latest channel version: 0.1.2
- activity: 1 stars, last push 2026-09-02T14:12:41Z, 33 commits last month / 33 last year

## Install

```sh
pixi shelf add mojo-window    # or plain: pixi add mojo-window
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo-yaml (binary package from the modular-community channel, mirrored on mojoshelf)

YAML Lite parser for Mojo - Native, zero-dependency YAML reader

- package name (registry/conda): `mojo-yaml`
- Mojo import name: `yaml` (e.g. `from yaml import …`) — guessed from the tin name, verify in the repo
- author: DataBooth
- repository: https://github.com/DataBooth/mojo-yaml
- latest channel version: 0.1.2
- activity: 0 stars, last push 2026-08-16T09:11:12Z, 1 commits last month / 27 last year

## Install

```sh
pixi shelf add mojo-yaml    # or plain: pixi add mojo-yaml
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo_csv (binary package from the modular-community channel, mirrored on mojoshelf)

Csv parsing library written in pure Mojo

- package name (registry/conda): `mojo_csv`
- Mojo import name: `mojo_csv` (e.g. `from mojo_csv import …`) — guessed from the tin name, verify in the repo
- author: phelsong
- repository: https://github.com/Phelsong/mojo_csv
- latest channel version: 1.6.3
- activity: 0 stars, last push 2026-09-05T02:11:28Z, 1 commits last month / 14 last year

## Install

```sh
pixi shelf add mojo_csv    # or plain: pixi add mojo_csv
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo_datetime (binary package from the modular-community channel, mirrored on mojoshelf)

A flexible Mojo datetime library implementation

- package name (registry/conda): `mojo_datetime`
- Mojo import name: `mojo_datetime` (e.g. `from mojo_datetime import …`) — guessed from the tin name, verify in the repo
- author: martinvuyk
- repository: https://github.com/martinvuyk/mojo_datetime
- latest channel version: 0.1.3
- activity: 4 stars, last push 2026-09-02T04:01:13Z, 13 commits last month / 115 last year

## Install

```sh
pixi shelf add mojo_datetime    # or plain: pixi add mojo_datetime
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojo_raylib (binary package from the modular-community channel, mirrored on mojoshelf)

|

- package name (registry/conda): `mojo_raylib`
- Mojo import name: `mojo_raylib` (e.g. `from mojo_raylib import …`) — guessed from the tin name, verify in the repo
- author: kivicode
- repository: https://github.com/kivicode/mojo-raylib
- latest channel version: 0.2.0
- activity: 9 stars, last push 2026-09-04T02:41:22Z, 8 commits last month / 45 last year

## Install

```sh
pixi shelf add mojo_raylib    # or plain: pixi add mojo_raylib
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojoblas (binary package from the modular-community channel, mirrored on mojoshelf)

mojoBLAS is a pure, high performance Mojo implementation of BLAS (Basic Linear Algebra Subprograms) routines.

- package name (registry/conda): `mojoblas`
- Mojo import name: `mojoblas` (e.g. `from mojoblas import …`) — guessed from the tin name, verify in the repo
- author: shivasankarka
- repository: https://github.com/shivasankarka/mojoBLAS
- latest channel version: 0.1.0
- activity: 9 stars, last push 2026-09-04T16:26:07Z, 22 commits last month / 155 last year

## Install

```sh
pixi shelf add mojoblas    # or plain: pixi add mojoblas
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojogp (binary package from the modular-community channel, mirrored on mojoshelf)

GPU-accelerated Gaussian Process library using Mojo kernels

- package name (registry/conda): `mojogp`
- Mojo import name: `mojogp` (e.g. `from mojogp import …`) — guessed from the tin name, verify in the repo
- author: caspbian
- repository: https://github.com/caspbian/mojogp
- latest channel version: 0.26.7.0
- activity: 0 stars, last push 2026-07-14T21:45:47Z, 0 commits last month / 8 last year

## Install

```sh
pixi shelf add mojogp    # or plain: pixi add mojogp
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mojopt (binary package from the modular-community channel, mirrored on mojoshelf)

A Mojo library for parsing CLI arguments using struct definitions.

- package name (registry/conda): `mojopt`
- Mojo import name: `mojopt` (e.g. `from mojopt import …`) — guessed from the tin name, verify in the repo
- author: sstadick
- repository: https://github.com/sstadick/mojopt
- latest channel version: 0.4.0
- activity: 1 stars, last push 2026-08-18T19:03:45Z, 4 commits last month / 67 last year

## Install

```sh
pixi shelf add mojopt    # or plain: pixi add mojopt
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# morrow (binary package from the modular-community channel, mirrored on mojoshelf)

Human-friendly date and time utilities for Mojo.

- package name (registry/conda): `morrow`
- Mojo import name: `morrow` (e.g. `from morrow import …`) — guessed from the tin name, verify in the repo
- author: Prodesire
- repository: https://github.com/mojoto/morrow.mojo
- latest channel version: 0.7.0
- activity: 125 stars, last push 2026-09-02T09:19:56Z, 6 commits last month / 169 last year

## Install

```sh
pixi shelf add morrow    # or plain: pixi add morrow
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mosaic (binary package from the modular-community channel, mirrored on mojoshelf)

An image processing library in Mojo

- package name (registry/conda): `mosaic`
- Mojo import name: `mosaic` (e.g. `from mosaic import …`) — guessed from the tin name, verify in the repo
- author: christianbator
- repository: https://github.com/brainwave-sh/mosaic
- latest channel version: 0.0.1
- activity: 14 stars, last push 2026-03-01T16:40:42Z, 0 commits last month / 29 last year

## Install

```sh
pixi shelf add mosaic    # or plain: pixi add mosaic
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# msl (binary package from the modular-community channel, mirrored on mojoshelf)

Mojo Scientific Library (MSL) is a comprehensive collection of scientific computation routines derived from GNU Scientific Library (GSL) written in pure Mojo.

- package name (registry/conda): `msl`
- Mojo import name: `msl` (e.g. `from msl import …`) — guessed from the tin name, verify in the repo
- author: shivasankarka
- repository: https://github.com/mojomath/MSL
- latest channel version: 0.1.0
- activity: 4 stars, last push 2026-09-04T07:11:32Z, 24 commits last month / 159 last year

## Install

```sh
pixi shelf add msl    # or plain: pixi add msl
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# mtest (binary package from the modular-community channel, mirrored on mojoshelf)

A pytest-like test runner for Mojo that orchestrates the stdlib's per-file TestSuite

- package name (registry/conda): `mtest`
- Mojo import name: `mtest` (e.g. `from mtest import …`) — guessed from the tin name, verify in the repo
- author: mikeleppane
- repository: https://github.com/mikeleppane/mtest
- latest channel version: 1.1.0
- activity: 4 stars, last push 2026-09-08T17:25:21Z, 0 commits last month / 918 last year

## Install

```sh
pixi shelf add mtest    # or plain: pixi add mtest
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# nabla (binary package from the modular-community channel, mirrored on mojoshelf)

Differtiable Programming in Mojo.

- package name (registry/conda): `nabla`
- Mojo import name: `nabla` (e.g. `from nabla import …`) — guessed from the tin name, verify in the repo
- author: TilliFe
- repository: https://github.com/nabla-ml/nabla
- latest channel version: 25.3.0
- activity: 348 stars, last push 2026-03-06T14:27:47Z, 0 commits last month / 467 last year

## Install

```sh
pixi shelf add nabla    # or plain: pixi add nabla
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# nanoid (binary package from the modular-community channel, mirrored on mojoshelf)

A Mojo port of NanoID, a tiny, secure, URL-friendly, unique string ID generator.

- package name (registry/conda): `nanoid`
- Mojo import name: `nanoid` (e.g. `from nanoid import …`) — guessed from the tin name, verify in the repo
- author: ucirello
- repository: https://github.com/cirello-py/nanoid
- latest channel version: 0.2.0
- activity: 0 stars, last push 2025-05-24T16:09:50Z, 0 commits last month / 0 last year

## Install

```sh
pixi shelf add nanoid    # or plain: pixi add nanoid
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# numojo (binary package from the modular-community channel, mirrored on mojoshelf)

NuMojo is a library for numerical computing in Mojo 🔥 similar to NumPy, SciPy in Python.

- package name (registry/conda): `numojo`
- Mojo import name: `numojo` (e.g. `from numojo import …`) — guessed from the tin name, verify in the repo
- author: shivasankarka
- repository: https://github.com/Mojo-Numerics-and-Algorithms-group/NuMojo
- latest channel version: 0.10.0
- activity: 237 stars, last push 2026-09-08T14:21:28Z, 13 commits last month / 101 last year

## Install

```sh
pixi shelf add numojo    # or plain: pixi add numojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# polars-mojo (binary package from the modular-community channel, mirrored on mojoshelf)

Polars DataFrame bindings for Mojo via Arrow C Data Interface

- package name (registry/conda): `polars-mojo`
- Mojo import name: `polars` (e.g. `from polars import …`) — guessed from the tin name, verify in the repo
- author: ethqnol
- repository: https://github.com/ethqnol/polars-mojo
- latest channel version: 0.1.0
- activity: 0 stars, last push 2026-09-08T22:20:07Z, 20 commits last month / 20 last year

## Install

```sh
pixi shelf add polars-mojo    # or plain: pixi add polars-mojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# projectodyssey (binary package from the modular-community channel, mirrored on mojoshelf)

Mojo-based AI research platform for reproducing classic research papers. Provides reusable tensor ops, autograd, layers, optimizers, and training infrastructure.

- package name (registry/conda): `projectodyssey`
- Mojo import name: `projectodyssey` (e.g. `from projectodyssey import …`) — guessed from the tin name, verify in the repo
- author: mvillmow
- repository: https://github.com/HomericIntelligence/ProjectOdyssey
- latest channel version: 0.1.0
- activity: 19 stars, last push 2026-09-03T07:57:29Z, 29 commits last month / 3709 last year

## Install

```sh
pixi shelf add projectodyssey    # or plain: pixi add projectodyssey
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# protomojo (binary package from the modular-community channel, mirrored on mojoshelf)

Protocol Buffers runtime and protoc plugin for Mojo

- package name (registry/conda): `protomojo`
- Mojo import name: `protomojo` (e.g. `from protomojo import …`) — guessed from the tin name, verify in the repo
- author: nsalerni
- repository: https://github.com/nsalerni/protomojo
- latest channel version: 0.4.2
- activity: 0 stars, last push 2026-09-06T03:24:03Z, 84 commits last month / 84 last year

## Install

```sh
pixi shelf add protomojo    # or plain: pixi add protomojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# rendercanvas-mojo (binary package from the modular-community channel, mirrored on mojoshelf)

- package name (registry/conda): `rendercanvas-mojo`
- Mojo import name: `rendercanvas` (e.g. `from rendercanvas import …`) — guessed from the tin name, verify in the repo
- repository: https://prefix.dev/channels/modular-community/packages/rendercanvas-mojo
- latest channel version: 0.1.0

## Install

```sh
pixi shelf add rendercanvas-mojo    # or plain: pixi add rendercanvas-mojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# safetensors-mojo (binary package from the modular-community channel, mirrored on mojoshelf)

An independent Safetensors format implementation for Mojo with checked validation

- package name (registry/conda): `safetensors-mojo`
- Mojo import name: `safetensors` (e.g. `from safetensors import …`) — guessed from the tin name, verify in the repo
- author: egor-fedorov
- repository: https://github.com/egor-fedorov/safetensors.mojo
- latest channel version: 0.5.0
- activity: 1 stars, last push 2026-09-02T22:34:48Z, 35 commits last month / 35 last year

## Install

```sh
pixi shelf add safetensors-mojo    # or plain: pixi add safetensors-mojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# small_time (binary package from the modular-community channel, mirrored on mojoshelf)

Datetime library forked from morrow.mojo

- package name (registry/conda): `small_time`
- Mojo import name: `small_time` (e.g. `from small_time import …`) — guessed from the tin name, verify in the repo
- author: thatstoasty
- repository: https://github.com/thatstoasty/small-time
- latest channel version: 26.2.0
- activity: 2 stars, last push 2026-05-18T16:44:49Z, 0 commits last month / 11 last year

## Install

```sh
pixi shelf add small_time    # or plain: pixi add small_time
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# stamojo (binary package from the modular-community channel, mirrored on mojoshelf)

A statistical computing library for Mojo

- package name (registry/conda): `stamojo`
- Mojo import name: `stamojo` (e.g. `from stamojo import …`) — guessed from the tin name, verify in the repo
- author: forfudan
- repository: https://github.com/mojomath/stamojo
- latest channel version: 0.2.0
- activity: 12 stars, last push 2026-08-14T18:59:59Z, 1 commits last month / 20 last year

## Install

```sh
pixi shelf add stamojo    # or plain: pixi add stamojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# strata (binary package from the modular-community channel, mirrored on mojoshelf)

Strata is a high-performance machine learning library written in native Mojo. It provides scikit-learn compatible estimator APIs while taking advantage of Mojo's compile-time optimizations and SIMD acceleration.

- package name (registry/conda): `strata`
- Mojo import name: `strata` (e.g. `from strata import …`) — guessed from the tin name, verify in the repo
- author: ethqnol # Ethan Wu
- repository: https://github.com/ethqnol/Strata
- latest channel version: 0.1.1
- activity: 9 stars, last push 2026-09-04T03:36:29Z, 207 commits last month / 207 last year

## Install

```sh
pixi shelf add strata    # or plain: pixi add strata
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# uuid (binary package from the modular-community channel, mirrored on mojoshelf)

A high-performance Mojo library for generating, parsing, validating, and formatting UUID values in RFC-9562 compatible string forms.

- package name (registry/conda): `uuid`
- Mojo import name: `uuid` (e.g. `from uuid import …`) — guessed from the tin name, verify in the repo
- author: lczerniawski
- repository: https://github.com/lczerniawski/uuid
- latest channel version: 1.2.0
- activity: 0 stars, last push 2026-09-01T15:28:33Z, 2 commits last month / 38 last year

## Install

```sh
pixi shelf add uuid    # or plain: pixi add uuid
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# vulkan-mojo (binary package from the modular-community channel, mirrored on mojoshelf)

Generated Mojo bindings for the Vulkan graphics API

- package name (registry/conda): `vulkan-mojo`
- Mojo import name: `vulkan` (e.g. `from vulkan import …`) — guessed from the tin name, verify in the repo
- author: Ryul0rd
- repository: https://github.com/Ryul0rd/vulkan-mojo
- latest channel version: 0.1.0
- activity: 13 stars, last push 2026-07-10T01:53:49Z, 0 commits last month / 162 last year

## Install

```sh
pixi shelf add vulkan-mojo    # or plain: pixi add vulkan-mojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# websockets (binary package from the modular-community channel, mirrored on mojoshelf)

Mojo's websockets library

- package name (registry/conda): `websockets`
- Mojo import name: `websockets` (e.g. `from websockets import …`) — guessed from the tin name, verify in the repo
- author: msaelices
- repository: https://github.com/msaelices/mojo-websockets
- latest channel version: 0.2.0
- activity: 22 stars, last push 2025-06-22T14:35:16Z, 0 commits last month / 0 last year

## Install

```sh
pixi shelf add websockets    # or plain: pixi add websockets
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.

---

# wgpu-mojo (binary package from the modular-community channel, mirrored on mojoshelf)

WebGPU for Mojo — pure bindings to wgpu-native, with RAII GPU objects

- package name (registry/conda): `wgpu-mojo`
- Mojo import name: `wgpu` (e.g. `from wgpu import …`) — guessed from the tin name, verify in the repo
- author: Hundo1018
- repository: https://github.com/Hundo1018/wgpu-mojo
- latest channel version: 0.2.1
- activity: 9 stars, last push 2026-09-07T12:35:09Z, 43 commits last month / 333 last year

## Install

```sh
pixi shelf add wgpu-mojo    # or plain: pixi add wgpu-mojo
```

A binary conda package; the solver picks the version — no registry pinning, and submodule mode does not apply.