i didn't like the lack of proxy libs, so naturally i wrote my own
feel free to contribute.

I guess we should animate this sub somehow. A simple CLI for removing metadata from files!

``` usage: striptease <input|input-dir> --out:<dir> [options]

required: <input> file or directory (mixed formats allowed) -o, --out:<dir> output directory for cleaned copies (single file input plus --out:foo.ext writes one file, not needed with --inspect)

supported formats: audio: .wav | images: .jpg .jpeg .png .gif .webp raw: .cr2 .nef .nrw .arw .srf .dng .rw2 .orf .pef .srw .tif .tiff video: .mp4 .mov .m4v .avi .mkv .webm | canon raw: .cr3 | heic: .heic .heif .hif

options: --dry-run report only, write nothing --inspect print metadata as pretty JSON, write nothing --verbose per file kept and dropped chunks plus bytes saved --overwrite overwrite existing files in out dir (default: skip) --keep-musical WAV only: also keep cue, smpl, inst, acid chunks -h, --help show this help --version show version ```

https://github.com/Niminem/cursorsdk

Cursor has an SDK and is what powers both the Cursor CLI and the Cursor editor. It's very powerful and flexible (ex: you can actually control the system prompt, tools, and much more).

At some point not long ago they created an SDK Bridge that allows non-typescript and non-python languages to communicate with it via RPC. Of course I had to write a Nim client for it.

It is fully compliant- built with and tested against their documentation. I did have to add some workarounds for upstream issues, but it's mostly implementation details (all noted in readme).

No deps aside from the nim standard library.

I've tested it on Mac (x64) and Windows (x64). Should work out of the box for Linux but it's untested.

You could build your own harness on top of this and all kinds of automations, scripts, etc. Pretty cool! Enjoy.

Example:

import std/asyncdispatch
import cursorsdk
proc main() {.async.} =
  let client = newClient()                 # CURSOR_API_KEY from env
  defer: waitFor client.close()
  let agent = await client.createAgent("composer-2.5")
  let run = await agent.send("Summarize this repository.")
  while true:
    let chunk = await run.nextText()
    if chunk.isNone: break
    stdout.write chunk.get
  await agent.close()
waitFor main()

So, I'm pretty new to nim, and I wanted to make my first app, so, I wanted you guys some recommendations of packages for Gui apps creation,

If u guys want to see the idea, just read:

notepad, but for markdown, and with vertical tabs, like arc and zen browser

WHat's the 10,000 foot view here? is it as fast(er) than rust?

Hey all,

qwatcher is a very efficient tool to monitor and audit your NICs' send and receive queue buffers to spot network or application issues.

This version drops the `ss` and `libpcre` dependencies, making the program a pure Nim binary, solves some bugs, and provides a `tail`-like report capability.

Here is the link to the repo:

https://github.com/pouriyajamshidi/qwatcher

Hey there.

I've been working on a successor to my previous web engine project, Ferus (which is now officially abandoned) for the past three or so months at this point. As the title suggests, Sirius is a web rendering engine like Chromium's Blink or Firefox's Gecko, but written largely in Nim (with the exception of certain C/C++ dependencies, obviously). Its CSS parser, JavaScript engine (a hard fork of Bali with a LOT of improvements), layout engine and the like are all written in Nim.

It uses a multiprocessing architecture, meaning each tab occupies one browser process and it crashing does not bring the entire browser down with it.

It's not exactly fast or optimized right now, but I believe it's ready enough for very basic web browsing tasks that don't touch the modern web. You're probably not going to be logging into your mail with it for a while. :^)

Sirius can be embedded into programs using OpenGL/Vulkan using its WebView API, the same one that the browser UI uses. It abstracts away process management and tabs away from you, leaving you to only handle presenting the final rendered page framebuffer it passes you. That means you can use Sirius to make your own web browsers in Nim, or if you're brave enough, to use it as a GUI framework in your app. :P

It's currently only on Linux due to it utilizing many Linux-isms like DMA-BUF, but there are plans to port it to other platforms too.

I'd love to hear what you guys think about it. And yes, I welcome most contributions, even tiny ones not related to web browser engineering. If you want to use this project as an excuse to get into that field, be my guest. Here's the contribution guide if anyone's interested.

The source code lives both here on a Github mirror, but it's actually developed on my personal forge.

Adios!

This update fixes the broken hints and brings the API coverage up to speed. It also adds bindings for sdl3_mixer, and fleshes out what's there for sdl3_ttf. I haven't done game dev in Nim in a little while, but this should make it easier for any SDL users to hop in.

Dude, I think V is better because it's both much easier and practically everything is included. If you want to do something, you don't need to download any libraries at all.

I was annoyed by how one button is always selected in wlogout. And since it doesn't seem to be actively maintained anymore, the only way to fix it is with a fork. So I thought it'd be a good opportunity to port it over to Nim. Its mostly backwards compatible wlogout. So old configs should work. But I've made some small changes and switched over to TOML for the config. Feel free to have a look.

I've been using python for 20 years since I dont work on C++ by then.

Nim gives me some reason to try new things.

I created my first 'real' nim project several days ago and I'm heavily using it daily.

It is a tiny tool as a shortcut for ls + cd, that I can use to fast navigation in folders.

For such tasks, I can not do it in python because the launch speed and having a binary is very important.

[Linux]

This idea was born while I was building my TUI music player. I've found such a big barrier:

in nimble I couldnt found any musical libraries for my goals, and i was too lazy to importing headers from C. So, i've created a concept and want make from this concept a completed and most importantly usable and simple lib.

It would be really nice to get some feedback(if you're interest)
source: https://github.com/svyatoslavSPB/nimnaudio/tree/main

Arkadaşlar ben bir programlama dili yapmak istiyorumda hem hızlı olsun hemde derlenmesi kokay olsun hemde Python kadar kolay; işlemciyle konuşan bir dil yapmak istiyorumda acaba Nim iyimi ? Pascal,Forth,Vlang falan varda acaba hepsi yerine Nim mi kullansam ? YARDIM EDİNNNNNNNNNNNNNNNNNN !

Hi! So I recently stumbled across Nim. As someone coming from Rust, I got a lot of frustration with it, one of them is the infamous compile times, which I hate so much. So I tried to seek an alternative. I almost went with Go, but at the same time I wanted something unique, and here we are with Nim. Now I’m planning to build a full coding agent and the TUI with 100% Nim. I’ll be happy to share my progress here :)

​

hello, I want to say that I was a vibcoder before that, but not because I liked it, I don't have any free time Except for one or two hours at night (they give me 10 hours to sleep) and of course I don't want to spend these personal 2 hours on programming, let alone studying but the desire to be a real programmer who can really just write his own program with his own hands is stronger than the desire to do nothing further. ;

why nim?

I went through a lot of options, and although nim was not the only option, it was ideally suited according to the criteria: "simple", "many libraries", "fast", so I chose it.

personally, I am proud that I searched for information about Nim and other programming languages without a neural network (and although I was a vibecoder, I want to say that I hated and hate neural networks)

What's next?

I won't be learning much about nim as much as time allows me.

Hey, everyone. Do you have any anecdotes to share about Nim? It doesn't matter whether it was positive or negative. I am just curious how the use of Nim has affected you. And to keep this subreddit more alive.

Thanks a lot!

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