Query Markdown as a Database with mq-db: SQL, mq, and Interval Indexes

via DEV Community: rust (author: Takahiro Sato)

AI in Healthcare: Why Implementation Fails in 2026

via DEV Community: rust (author: Maverick-jkp)

Web Developer Travis McCracken on Rust vs Go in Production APIs

via DEV Community: rust (author: Travis McCracken Web Developer)

I built a local-first AI memory layer for LLMs in Rust (no cloud, no API keys)

Every LLM app has the same problem — the model forgets everything between
conversations. Cloud solutions like Mem0 exist but they send your data
to their servers. I built mnemo to solve this locally.

What it does

mnemo runs as a sidecar process next to your app. You POST text to it,
it extracts named entities and relationships using a local LLM (Ollama),
builds a persistent knowledge graph, and injects relevant context back
into your prompts automatically.

The stack

● Rust — core engine, 4 crates (mnemo-core, mnemo-api, mnemo-cli, mnemo-bench)
● SQLite + WAL mode — persistent storage, survives restarts
● petgraph — in-memory knowledge graph with BFS traversal
● Axum — REST API sidecar any app can call
● Ollama — fully local LLM, zero API costs

Fully free by default

docker compose up -d
docker exec mnemo-ollama ollama pull llama3
curl http://localhost:8080/health

Works with OpenAI or Anthropic too if you bring your own key.

Python SDK

from mnemo import MnemoClient

client = MnemoClient()
client.ingest("I'm building a Rust vector database called vecdb")
print(client.get_context("what am I working on?"))

Numbers

● 122 Rust tests, 21 Python SDK tests
● Sub-millisecond entity lookup
● ~4ms full retrieval pipeline (debug build)

Links

GitHub: https://github.com/zaydmulani09/mnemo

Would love feedback, especially on the retrieval scoring and graph
traversal approach.

via DEV Community: rust (author: Zayd Mulani)

I built a Rust CLI because I kept forgetting to open my todo app

I always wanted to organize my tasks in a todo app, but because the habit was new, the next day i would always forget the existence of it. So i built something that opens itself (or, well, whenever your terminal does, by default)

Meet Amnosia. The CLI Tool that opens whenever your terminal does.
It's different from a regular todo app, because it gets in your face (in a good way!)

Install

To install, you can just clone the repo on github and then use cargo to put it in your PATH.

git clone https://github.com/GennaroBiondi/amnosia
cd amnosia
cargo install --path .

Usage

adding reminders, seeing them, and deleting them, is as easy as three commands:

The magic part

Add this to your .zshrc or .bashrc:

amnosia remind -n 7

Now every time you open a terminal, your reminders are right there.
No app to open. No habit to build.

You can view more here on github

via DEV Community: rust (author: Gennaro Biondi)

Why Software Should Be a Graph, Not Text

via DEV Community: rust (author: Gábor Heizer)

Mutagen 0.4.0 Released: Service Extraction, Bug Crunches, and Fixed Persona Drift

via DEV Community: rust (author: Jay Grider)

I built a free, native MongoDB GUI in Rust (Tauri) — why, and what I learned

via DEV Community: rust (author: Devesh Kumar)

Go + Gin Rust: HTTP Middleware & Web Servers

via DEV Community: rust (author: Andrei Merlescu)

Why your LLM tool calls silently break — and a ~10µs fix

via DEV Community: rust (author: Wu Jiang)

This Week in Rust 654

via This Week in Rust (author: TWiR Contributors)

This Week in Rust 655

via This Week in Rust (author: TWiR Contributors)

I built a portable serial terminal for ESP32/Arduino in Rust — because my board kept resetting

If you debug ESP32 boards over serial, you probably know this one: you flash the firmware, rush to open a serial monitor to catch the boot logs… and the act of opening the monitor resets the board. The DTR/RTS lines toggle on connect, the ESP32 auto-resets, and the first lines you actually wanted are gone.

I hit this enough times that I built my own terminal.

CNTerminal
Live + download: https://www.coding-now.com/en/cnterminal Source (MIT): https://github.com/cflab2017/tool_serial_terminal_Rust

It's a free, portable serial terminal for Windows — a single ~8 MB .exe. No installer, no runtime, no admin rights: drop it on a USB stick, run it on a locked-down lab PC, done.

What it does:

DTR / RTS control — the reason it exists. Keep DTR from toggling on connect and the ESP32 doesn't auto-reset, so you actually see the boot output.
HEX send & receive — for binary protocols, plus an ASCII ↔ HEX converter built in (no more alt-tabbing to a converter site mid-debug).
5,000-line auto-trim — long logging sessions don't slowly eat your RAM or lag the UI.
The usual: port/baud selection, timestamps, a dark amber CRT theme that's easy on the eyes during long sessions.
Why Rust + egui
I wanted a single file people could run anywhere, which ruled out anything with a runtime. Rust + egui turned out to be a great fit: the whole GUI app compiles to one small native binary, immediate-mode UI keeps the serial read loop and the rendering loop simple to reason about, and serialport-rs handles the device side.

The trickiest part wasn't the UI — it was making the serial reader thread, the auto-trimmed scrollback buffer, and the GUI repaint cooperate without dropping bytes at high baud rates. If you're curious, the source is MIT and pretty small.

Honest scope
Windows only for now (single-exe portability was the goal).
It's a terminal, not an IDE plugin — it does serial I/O well and nothing else.
If you live in a serial monitor — Arduino, ESP32, STM32, industrial gear over RS-232 — give it a try and tell me what's missing compared to your current setup. Feature requests and bug reports are very welcome, here or on GitHub.

via DEV Community: rust (author: 코딩나우(하늘아래))

Why I still teach Singleton even though modules make it redundant

Ask any developer what design pattern they know best and Singleton comes up first. Ask the same group if they use it in production and half will say no. The module system already does the job.

They're right. But I still include it in my patterns reference, and here's why.

What Singleton actually solves

The pattern ensures a class has only one instance and provides a global access point to it. Shared configuration loaded from env vars, a logger that buffers output, a connection pool you don't want duplicated. That kind of thing.

The classical JavaScript version looks like this:

class Config {
  static #instance = null;
  #data;

  constructor() {
    this.#data = {
      apiUrl: process.env.API_URL ?? "http://localhost:3000",
      timeout: Number(process.env.TIMEOUT ?? 5000),
    };
  }

  static getInstance() {
    if (!Config.#instance) {
      Config.#instance = new Config();
    }
    return Config.#instance;
  }

  get(key) {
    return this.#data[key];
  }
}

Boilerplate. Every time.

The module alternative
In JavaScript and Python, a module is already a singleton. The runtime caches it after the first import. So the same Config above becomes:

// config.js
export const config = {
  apiUrl: process.env.API_URL ?? "http://localhost:3000",
  timeout: Number(process.env.TIMEOUT ?? 5000),
};

// anywhere else
import { config } from "./config.js";

Same object, every import, no class, no getInstance(). Python works identically.

So the pattern is "redundant" in the sense that you'd rarely write the classical version in a modern JS or Python codebase. You'd just export a module-level object.

Why I still teach it

Three reasons.

You will read it in older code. Codebases written before ES modules were standard, Python 2-era code, Java and PHP services. If you've never seen the pattern explained properly, you'll waste time figuring out what the class is doing.

It makes the intent explicit. A plain exported object and a Singleton both enforce one instance, but the Singleton makes that constraint visible and enforced at the type level. In teams, explicit beats implicit.

Rust does not have the shortcut. OnceLock (stable since 1.70) or LazyLock (stable since 1.80) is the idiomatic way to get a static singleton in Rust. There is no module-level trick.

use std::sync::LazyLock;

static CONFIG: LazyLock<Config> = LazyLock::new(Config::from_env);

That is the pattern, just dressed in modern syntax.

The broader point

This is what I tried to do with the whole reference. For each of the 23 GoF patterns, show the classical approach and then show what modern language features replaced or simplified it. Some patterns are still essential. Some you'd only write in a language without the shortcut. Some you'll only encounter as a reader, not a writer.

The reference covers all 23 patterns plus the 5 SOLID principles, with examples in JavaScript, Python, and Rust. MIT licensed.

https://github.com/dsheiko/design-patterns-for-web-developer

via DEV Community: rust (author: Dmitry Sheiko)

Web Developer Travis McCracken on DevOps Tips from a Web Developer

via DEV Community: rust (author: Travis McCracken Web Developer)

5 Features That Make chematic Stand Out as a Pure-Rust Cheminformatics Library

via DEV Community: rust (author: kent-tokyo)

BoxAgnts Tool System (5) — WASM Tool Development: From Hello World to Production Deployment

via DEV Community: rust (author: Guyoung Studio)

When JavaScript Isn't Fast Enough

via DEV Community: rust (author: Boris Barac)

A true “chaos” event just hit the Rust ecosystem! 😅

via DEV Community: rust (author: venelouis)

🦀 From Zero to the Perfect App with Rullst! 🚀

via DEV Community: rust (author: venelouis)

📜🦀Rullst is smashing all the other frameworks!

via DEV Community: rust (author: venelouis)