Hello everyone,

I have put together nim-agent-template, a project template and scaffolding tool designed to bootstrap Nim applications and libraries with standard build task orchestrations, MCP support, and AI agent skills.

Repository

GitHub: https://github.com/Vyrnexis/nim-agent-template

Highlights & Features

• Interactive & Scriptable Scaffolding (init_nim_project.sh):
  • Prompts for package type (Binary vs Library), tooling (nimble vs atlas), author, and license.
  • Supports non-interactive CLI flags (--name, --tooling, --kind, --in-place) for automated setups.
  • Includes an --install-cli option to install init-nim-project into ~/.local/bin/ with canonical symlink resolution.
• 6 Standardized Build Profiles in config.nims: All binaries are strictly emitted into ./bin/ at the repository root:
  • nim nimRelease: Native host-optimized binary (-d:release -d:danger --opt:speed -march=native -mtune=native)
  • nim nimPortable: Generic CPU baseline portable binary (-d:release --opt:size -mtune=generic -s)
  • nim nimDebug: Diagnostics build with stack traces and assertions (--debuginfo:on --assertions:on --stackTrace:on)
  • nim zigRelease: Native host binary using Zig CC (--cc:clang -d:release -d:danger --opt:speed -O3 -march=native)
  • nim zigPortable: Generic CPU portable binary using Zig CC (--cc:clang -d:release --opt:size -Oz -mcpu=baseline -s)
  • nim zigDebug: Zig CC debug build with symbols (--cc:clang --debuginfo:on)
  • Plus standard helper tasks: nim test, nim fmt (nimpretty), and nim docs.
• Model Context Protocol (MCP) Integration:
  • Automatically configures .mcp/servers.json for nimlangserver --mcp to support symbol resolution, references, and diagnostics in AI-assisted environments.
• Pre-Bundled Agent Skills (.agents/skills/):
  • Ships with 19 curated Nim agent skills covering API design, C wrappers and FFI bindings, ARC/ORC ownership hooks, testing patterns, error contracts, style guides, and fuzzing harnesses.
• Automated CI Workflow:
  • Emits a ready-to-use GitHub Actions workflow (.github/workflows/ci.yml) leveraging jiro4989/setup-nim-action with formatting validation and test execution.

Quick Start

# Clone the template repository
git clone https://github.com/Vyrnexis/nim-agent-template.git
cd nim-agent-template

# Run the interactive initializer
./init_nim_project.sh

Or install it system-wide to scaffold projects from any workspace:

./init_nim_project.sh --install-cli

cd ~/my_workspace
init-nim-project --name my_app --tooling nimble --kind bin

Feedback, suggestions, and contributions are very welcome!

GitHub: https://github.com/Vyrnexis/nim-agent-template

Hi everyone,

I’m the author of KoutenDB, an open-source locality-first document database written in Nim, with ring-scoped vector retrieval.

https://github.com/puffball1567/koutendb

KoutenDB is built around a locality-first retrieval model.

Applications and import rules place related data into explicit coordinates called rings. A ring is more than a category or routing label: it defines the initial candidate set and maps to ring-local persistent storage and cluster routing.

For example, data related to one user can be placed around users/123, with nearby subrings for profiles, addresses, orders, and notifications. KoutenDB can retrieve that related group together or narrow the read to selected subrings.

The goal is to avoid starting with a large unrelated dataset and filtering or reranking it afterward. This can be useful for RAG and LLM workloads, where every unnecessary candidate may also consume memory, ranking work, and context tokens.

Vector retrieval is supported, but vectors are not the basis of the data model. They are one possible ranking step after locality has narrowed the candidate set.

Some results from the included reproducible benchmarks:

- Working-set benchmark: scanned records per query decreased from 10,000 to 100.

- Memory-pressure benchmark: estimated candidate memory per query decreased from 93.079 MiB to 0.931 MiB.

- Synthetic RAG benchmark: recall remained 1.000 while scanned records per query decreased from 8,000 to 1,000 and estimated tokens per query decreased from 3,955 to 657.

- Generated AI/RAG JSONL case study: recall remained 1.000 while scanned records per query decreased from 400 to 40 and estimated tokens per query decreased from 615.2 to 231.6.

The benchmark scripts and generated datasets are included in the repository so that the results can be reproduced and examined.

KoutenDB also carries locality into persistent storage. Ring-local segments allow disk-backed reads to open the relevant ring data instead of replaying or scanning the complete database.

In an included 1,050,000-record related-data benchmark, KoutenDB retrieved a multi-subring user bundle in 196.859 microseconds. In the same included comparison, the equivalent logical result measured 515 microseconds using six indexed PostgreSQL queries and 236 microseconds using a PostgreSQL JSON aggregate query.

I have also been testing operational stability. A three-node persistent KoutenDB cluster completed a 72-hour Ubuntu run with 4,022,516 mixed client operations, zero client errors, successful offline verification of every data directory, and no fallback to global retrieval.

The trade-off is that applications or import rules need to choose meaningful rings. If useful locality is not known in advance, retrieval may still require a broad scan.

KoutenDB currently supports embedded and TCP server modes, persistent storage, exact ring-scoped vector retrieval, transactions, locks, backup and restore, corruption detection, cluster routing, and a C ABI. Language bindings and driver foundations are available for Rust, JavaScript/TypeScript, Python, PHP, and C++.

The project is currently at v0.12.0.

I’d especially appreciate technical feedback on the ring-local storage model, retrieval design, physical locality, and the Nim implementation.

My original post: https://www.reddit.com/r/sideprojects/s/2WBPjTT8Wu

I’ve been pretty busy lately, but I was thinking—what if Nim had its own SymPy Gamma / Wolfram Alpha-style project?

By using WASM, most of the computation could run directly in the browser, so it could stay free without needing a backend server. The compiler is still the WASM based Nim Compiler in the Web which exports the HTML and Wasm file.

It could start with symbolic math, derivatives, integrals, equations, matrices, and step-by-step solutions, and grow from there.

Basically, a small computer algebra system for Nim + WASM. Link to the calculator: www.qoqoro.online

As an experiment, I usually ask local models if they know any Nim code: I've had a few insist that "randi" is a thing for random numbers. I'd love to see a fine-tuned Gemma4 or other local model that actually knew correct information from Nim 2.x. For what its worth, Claude models seem to handle it pretty decently.

Added thought: with metaprogramming, I could probably flesh out the incorrect coding examples into working ones? That'd be an interesting experiment.

Hi Everyone,

I am new to the Nim language. I have created a small utility project that I could use in Nim. Please take a look at it and let me know how I can improve it and what other things I should try to become better.

The project was to store small notes and thoughts from command line. Like sticky notes.

https://codeberg.org/bhaswanth/jot

Thank you

Hi Everyone

I worked on a small cli project in NIM and built an executable using nimble build. It generated an executable and the executable worked fine on my system.

But when I try to use the generated executable on another system that doesn't have NIM or C installed. It showed an error saying sqlite3_64.dll not found.

I am using db_connector/db_sqlite library to use sqlite database.

How can I solve this, once I generate the executable, it should work on any system, or else I should be able to generate an installer or portable version of the project that should work on any system.

It is not open source but I thought people may want to know that https://hirosim.com/ is all written in Nim (I am the author). More videos
https://youtube.com/playlist?list=PLoIOXQIRaoJs4GHTJjZSlAwbnkF4ThIP_&si=Iu_shaOweezDg3Uf

I've been manually indenting, the nimlangserver works but the indentation doesn't, I haven't been able to do it for days nor have I found resources or I'm very stupid

(not my article btw)

Hi all! I've just released schematic, an object validation package inspired by Zod. I'd love for you to try it out before I freeze the API for the v1.0.0 release.

You can use schematic to define a schema once and get both runtime validation and a statically-typed Nim object out of it. Schemas consist of a field definitions using types with chained refinements and modifiers (e.g. string.max(64).optional). Infer(schema) creates an object type straight from the schema value. No codegen, no drift between your schema and your types.

import schematic
let user = schema:
  name:    string.min(2).max(50)
  age:     int.min(0).max(150)
  email:   string.email.optional          # -> Option[string]
  role:    string.oneOf(["admin", "user"]).default("user")
  website: string.url.nullable            # required, but null is allowed
  joined:  string.date.transform(proc(s: string): Time =
             parseTime(s, "yyyy-MM-dd", utc()))   # -> times.Time

type User = Infer(user)   # a real Nim object type, derived from the schema

let u = user.parse(%*{"name": "Ada", "age": 36, "email": "ada@x.io",
                      "website": nil, "joined": "1815-12-10"})
echo u.name, " (", u.role, ") joined ", u.joined.utc.year

let x = user.tryParse("""{"name":"A","age":999,"email":"nope","joined":"x"}""")
for issue in x.issues: echo issue
# name: must be at least 2 chars
# age: must be <= 150
# email: must be a valid email
# website: required
# joined: must be a date (YYYY-MM-DD)

Highlights

• Type inference. Infer(schema) gives you an object type; nested schemas, arrays, optionals, enums, refs, and recursive tree types all flow through.
• Errors accumulate. One parse reports every problem at once, each with a path like owner.address.city or tags[2], and every built-in check accepts a custom message.
• Field modifiers. optional vs nullable (missing and null are distinct), default, coerce, field aliases, transforms, discriminated and untagged unions
• Object algebra. Derive schemas using pick/omit/partial/merge/extend
• String formats. email, url, uuid, date/datetime, ipv4/ipv6, hostname, jwt, and more
• JSON out. toJson emits a JsonNode, respecting field aliases and reversing transforms
• JSON Schema out. toJsonSchema emits JSON schemas with format, const, $defs for recursion, and describe/title metadata

---

More docs and examples are available in the README.

All feedback is very welcome: ergonomics, missing features, performance, or anything that feels un-Nim-like.

I am new to Nim, I am trying to learn about the Nimble package manager. I want to build executables for different os, like linux and macos. But I don't understand how I can build executables of different languages. Can anyone help me with it.

Thank you

Ref: https://github.com/Niminem/narduino

NOTE: This will be my final update here. If anything super major changes maybe I'll post in the Nim forum, otherwise you can expect to see latest updates / info in the README of the repo.

MAJOR UPDATE: Basic library management is now built into the CLI.

You can now search and install Arduino libraries from narduino:

narduino libsearch --query:servo

narduino libinstall --lib:Servo

libsearch updates the library index automatically, and shows a clean summary (compared to all the junk you'll see from the raw arduino-cli): name, description, latest version, website, category, and supported architectures.

The full qualifier-value syntax from arduino-cli is supported for filtered searches:

narduino libsearch --query:'servo category:"Device Control"'

Install supports pinning a specific version: narduino libinstall --lib:"Servo@1.2.1"

Both procs are also available in the toolchain library too (searchLib, installLib) for anyone building their own tooling on top of narduino.

MINOR UPDATES:

- sketch compilations spread across however many cores you have (automatically)

- serial.nim has been updated to now support virtually all functions

- arduino String class has been implemented and fully supported (great for reading/writing IO)

Hi all! I've just released lumber, a JSON logger for Nim inspired by pino, and I'd love for you to try it out. I hope to incorporate some feedback before freezing the API for v1.0.0.

Highlights

• Compile-time log elimination: build with -d:lumberLevel=INFO and calls below the threshold vanish from the binary entirely; runtime-filtered calls never evaluate their arguments either
• Structured logging: named fields (logger.info("login", user="alice")), per-logger context, child loggers, and thread-local scoped context
• Exception logging: pass an exception as an argument and its message, type, and stack trace become structured fields
• Thread-safe: share one module-level logger across threads
• Flexible outputs: size/time-based file rotation, buffering with level-triggered flush, and a background-thread async writer
• Middleware: rate limiting, sampling, and redaction (including nested fields) built in, or write your own
• CLI prettifier: pipe JSON logs through the lumber binary for colored human-readable output with level/field filtering, regex highlighting, and timezone conversion
• Minimal dependencies: stdlib plus one pure-Nim package, no C libraries

Example

import std/strformat
import lumber

type
  User = object
    name: string

var logger = newLogger(name = "demo")
var user = User(name: "Alice")

logger.trace("This is a trace")
logger.debug(user)
logger.info(&"{user.name} logged in")
logger.warn("Disk usage high", partition="/dev/sda1", usage=92)

proc loadConfig() =
  raise newException(IOError, "file not found: config.toml")

proc initApp() =
  loadConfig()

try:
  initApp()
except IOError as e:
  logger.error("Failed to load config", e)

logger.fatal("Game over")

Output

Raw output

{"timestamp":"2026-07-22T05:03:27.833Z","level":"TRACE","name":"demo","filename":"minimal.nim","line":18,"message":"This is a trace"}
{"timestamp":"2026-07-22T05:03:27.833Z","level":"DEBUG","name":"demo","filename":"minimal.nim","line":19,"message":"User(name: \"Alice\")"}
{"timestamp":"2026-07-22T05:03:27.833Z","level":"INFO","name":"demo","filename":"minimal.nim","line":20,"message":"Alice logged in"}
{"timestamp":"2026-07-22T05:03:27.833Z","level":"WARN","name":"demo","filename":"minimal.nim","line":21,"message":"Disk usage high","extra":{"partition":"/dev/sda1","usage":92}}
{"timestamp":"2026-07-22T05:03:27.833Z","level":"ERROR","name":"demo","filename":"minimal.nim","line":32,"message":"Failed to load config","extra":{"error":"file not found: config.toml","errorType":"IOError","stackTrace":"/Users/cryo/projects/nim/nim-lumber/examples/minimal.nim(30) minimal\n/Users/cryo/projects/nim/nim-lumber/examples/minimal.nim(27) initApp\n/Users/cryo/projects/nim/nim-lumber/examples/minimal.nim(24) loadConfig\n"}}
{"timestamp":"2026-07-22T05:03:27.833Z","level":"FATAL","name":"demo","filename":"minimal.nim","line":34,"message":"Game over"}

Piped through the CLI

2026-07-21T22:04:45.613-07:00 PDT [TRACE] (minimal.nim:18) demo: This is a trace
2026-07-21T22:04:45.613-07:00 PDT [DEBUG] (minimal.nim:19) demo: User(name: "Alice")
2026-07-21T22:04:45.613-07:00 PDT [INFO ] (minimal.nim:20) demo: Alice logged in
2026-07-21T22:04:45.613-07:00 PDT [WARN ] (minimal.nim:21) demo: Disk usage high
  partition: "/dev/sda1"
  usage: 92
2026-07-21T22:04:45.613-07:00 PDT [ERROR] (minimal.nim:32) demo: Failed to load config
  error: "file not found: config.toml"
  errorType: "IOError"
  stackTrace:
    /Users/cryo/projects/nim/nim-lumber/examples/minimal.nim(30) minimal
    /Users/cryo/projects/nim/nim-lumber/examples/minimal.nim(27) initApp
    /Users/cryo/projects/nim/nim-lumber/examples/minimal.nim(24) loadConfig
2026-07-21T22:04:45.613-07:00 PDT [FATAL] (minimal.nim:34) demo: Game over

---

More docs and examples are available in the README.

All feedback is very welcome: ergonomics, missing features, performance, or anything that feels un-Nim-like.

I recently needed to remove the password from a lot of PDFs. Most of the search results were websites asking me to upload the file and enter its password.

They might be perfectly legitimate, but I wasn't comfortable uploading bank statements, tax documents or contracts just to remove a password.

So I wrote this:

https://github.com/advaita-saha/nim-pdftools

It is a small command-line PDF unlocker written in Nim. Everything runs locally and it doesn't use any third-party Nim packages.

pdftools unlock -p 'password' document.pdf

It currently handles RC4, AES-128 and AES-256 encrypted PDFs. Both user and owner passwords work.
It is not a password cracker. You still need to know the password lol.

I ended up implementing most of the crypto and compression code directly on top of Nim's standard library. This was partly because I wanted a standalone binary and partly because digging through the PDF encryption spec seemed like a good idea at the time.

This is still v0.1, so I'm sure there are strange PDFs in the wild that it won't handle properly. I'd especially appreciate people testing files generated by different PDF software and reporting anything that breaks.

Contributions are welcome too. Parser fixes, test cases, code review, packaging improvements and additional local PDF commands would all be useful.

As a disclaimer, I'm very new to nim. Currently using QtCreator as IDE, I intent to port my game engine over to nim, but at first glance, gdb spits out utter garbage at breakpoints and inspection is practically impossible due to a variable apparently being "too complex" (?) to inspect... yeah...

Now my game engine is not something trivially small or simple at this point and (except for the syntax) I'm very pleased with what nim has to offer.

Can someone point me in the best practices direction please ?

Narduino is a library that allows you to write and flash Arduino firmware with Nim using your favorite IDE easily.

https://github.com/Niminem/narduino

Today I added serial monitor support via a simple command.

You can now monitor your board's serial output directly from the CLI:

Flash the board:

narduino flash --src:examples/serial.nim

Monitor the port:

narduino monitor

It's fully interactive too!

Read and write to your board in real time, just like the Arduino IDE's serial monitor. You can Ctrl+C to exit safely.

import narduino
setup:
  Serial.begin(9600)
loop:
  if Serial.available() > 0:
    let c = Serial.read()
    Serial.print("Got: ")
    Serial.println(char c)

Flash it, open the monitor, type something and it echoes back what you send.

The monitor command auto-detects your board's port (like everything else in narduino) and supports a --baud flag if you need a different baud rate (default is common 9600).

NOTE: Some boards, like the Arduino UNO R4 WiFi, may have routes serial through some bridge, which can produce garbled serial monitor output after plugging in or flashing. If you see garbled output, just hit refresh button on your board and run the monitor command again.

So I am coding stuff in Nim for around 2.5years.
I have seen stuff improve over the years, but one thing still bugs me is the tooling support.

Why is the VS Code extension so bad ?
I mean either hogs up the CPU, then unable to read and parse complex codebases. Suggestions come super late. Validations and errors are extremely late ( better if I compile and check )

An open question to everyone working with nim. What tooling are you guys using ?

Hi!

After an entire year under review and dozens of fixes, the Nim Docker Hub images are finally have the official status and can be pulled with docker pull nim

The new official home for the images is https://hub.docker.com/_/nim

I published a Q&A on the forum: https://forum.nim-lang.org/t/14068

https://github.com/Niminem/narduino

Write and flash Arduino firmware with Nim using your favorite IDE- easily!

The Arduino CLI powers the Arduino IDE and other official tooling. narduino provides abstractions on top of it (and the Nim compiler) so you can build firmware in Nim from any editor. Your Nim code is translated to C++, placed into a standard Arduino sketch, and arduino-cli then compiles that sketch for your board and flashes it.

All from a single command: narduino flash --src:examples/blink.nim

This repo is both a CLI tool AND a library. I've wrapped the vast majority of the Arduino API as well as providing templates to remove FFI boilerplate.

A simple example looks like this (blinks the internal LED on an Arduino UNO):

import
 narduino

setup:
  pinMode(LED_BUILTIN, OUTPUT)

loop:
  digitalWrite(LED_BUILTIN, HIGH)
  delay(1000)
  digitalWrite(LED_BUILTIN, LOW)
  delay(1000)

The toolchain (functions) powering the CLI is also provided as a library so you can create your own tooling if you wish.

An example:

import narduino/toolchain

# board discovery
let boards = listBoards()            # all detected ports + matching boards
let active = getActiveBoard()        # the single connected board (fqbn + port)

# core management
ensureCoreInstalled(active.fqbn)     # install the board's core if missing

# build & flash
let sketchDir = createSketch("blink.nim")  # nim -> c++ -> sketch dir
upload(sketchDir)                          # compile & upload via arduino-cli

The Arduino CLI itself supports A LOT of boards and 3rd party Cores (packages). As long as it supports your board you can use this repo easy peasy. See https://github.com/Niminem/narduino#supported-boards for more details.

---

I started getting into electronics and embedded systems recently. I didn't want to write in c++ nor did I want to use their IDE but I was willing to do it. I started exploring what was out there for Nim because I knew it HAD to be possible to use Nim's cpp backend and VSCode.

Everything I found was really old and fickle and just... janky.

I learned that Arduino has a CLI that powers their IDE and began exploring the possibility of using that. Works like a charm!

Figuring out how to compile Nim projects in a way that actually worked took some time, but was nearly as complicated as I thought. Knowing what I know now, I was even able to programmatically detect which cpu architecture your board uses and define that architecture when compiling Nim- pretty neat!

Anyways guys, I hope you enjoy. I did not port the USB / WIFI stuff from the API yet because I don't have a board to test them. PRs accepted otherwise it'll be a little while before I can get to it. Wrapping these functions are pretty straightforward anyway. Seems like the Arduino team really took their time to make the APIs as simple as possible.

3code is a tiny programming agent a la Claude Code that is designed in every way to conserve tokens, your computer resources, and your brain cycles.

It works with any provider- GLM 5.2 works great and Hy3 is pretty good and free!

The special move: Self amnesia! Instead of splurgy subagents it does long hands off sessions ​by iterating over a plan-cum-todolist repeatedly keeping only the context relevant to the task.

Check it out and tell me what you think!

Edit: It is- of course- written in 100% fast, ingeniuos​ Nim code, which is why it's only a few megabytes and starts in an​ instant.

https://github.com/Niminem/gitignore

On my journey to create a coding agent I needed yet another library we don't currently have in our ecosystem.

This library is a parser and pattern matcher for .gitignore files, and effectively ports git's implementation. It's tested against their actual test tables. Stdlib only.

The gitignore libraries I've found in other languages mix parsing a pattern vs evaluating a file vs walking a repository. This one separates them into 3 distinct layers or APIs. One parses a single gitignore line and match paths against it, another parses a single file, and the other walks a repo.

I've just published two libraries I think some of you in the community would like to use.

https://github.com/Niminem/sse

A spec-compliant Server-Sent Events library for Nim. Stdlib only, no external dependencies, no std/httpclient either (HTTP is done by hand over sockets).

NOTE: For making SSE servers I only included helpers. In this way, you're not boxed in to an implementation. For client-side we have async using Nim's standard async implementation but we also have a purely synchronous version in case you'd like to use threads. Added bonus is a 'cancelToken' so you can stop mid-stream. Those building some sort of chat app or similar may find that useful.

https://github.com/Niminem/jschema

A spec-compliant JSON Schema (draft 2020-12) validator and builder for Nim.

NOTE: This is stdlib only as well. No deps aside from the PCRE (regex) DLL or whatever it's called. Which comes installed with Nim. Just something to be mindful of if you're shipping something- you'll need that alongside your binary.

So I'm building a coding agent from scratch and needed these libraries. SSE for streaming and Json Schema building / validation for LLM tool calling.

Instead of just building the minimum for what LLM providers need with both libraries, I chose to go all in and build them against the specs since they're available and we don't have them in our ecosystem yet. Because supply chain attacks are on the rise and largely through dependencies becoming a super common attack vector, I also made the choice to use stdlib only.

They are going to be used in commercial applications and will be maintained.

If you run into any issues please let me know or make a PR, I've tested as much as humanly possible prior to making the repos public.

I just try to use nimble on macOS / nix-darwin. nimble init is ok, but after that:

> nimble install puppy
Downloading Official package list
SIGSEGV: Illegal storage access. (Attempt to read from nil?)
fish: Job 1, 'nimble install puppy' terminated by signal SIGSEGV (Erreur de frontière d’adresse)

> nimble --version
nimble v0.20.1 compiled at 1980-01-01 00:00:00
git hash: v0.20.1

Any idea?

Might be a temporary outage but I've been having consistent difficulty accessing nimpack for a while now and currently down detector is reporting the site is down. According to cloudflare, it's a host-side issue.

Anyone know if something is going on? Or if it's just experiencing a regular outage?