标签：#rust

GitHub热门项目 | ⭐️ A friendly language for building type-safe, scalable systems! | Stars: 21,807 | 26 stars today | 语言: Rust

GitHub热门项目 | cursor-byok is a local implementation of Cursor's backend. https://github.com/leookun/cursor-byok/releases | Stars: 2,500 | 26 stars today | 语言: Rust

GitHub热门项目 | An idiomatic, lean, fast & safe pure Rust implementation of Git | Stars: 11,840 | 10 stars today | 语言: Rust

Originally published at ai.bedvibe.studio . I built a real-time tracker in Rust — about two thousand lines — that reads a live ADS-B feed, keeps a Kalman-filtered track per aircraft, and screens every pair for closest approach against separation minima. Roughly 150 aircraft, a full cycle in under a millisecond. It ran clean. Tests passed, the picture looked right, the numbers were plausible. It was refusing about one measurement in nine , and the only reason I ever found out is that the rejections went to a counter instead of a log line. The gate has a sub-second tolerance for clock error The tracker runs an innovation gate: when a position arrives, the filter predicts where the aircraft should be, and if the measurement is too far from that prediction it is rejected as physically impossible rather than believed. Once a track converges the innovation standard deviation settles around 36 m, so a five-sigma gate sits at roughly 180 m. An airliner at 250 m/s covers 180 m in 0.7 seconds . So the gate's entire tolerance for a wrong timestamp is under one second. Any pipeline that mis-times its measurements by more than that will have them rejected — correctly, and invisibly. The feed reports its own staleness. The pipeline dropped it. Every ADS-B record carries a field saying how old that position already was when the response was generated. In the original build it was parsed into the contact struct and never read again — the only other place that field appeared in the entire codebase was as 0.0 in test fixtures. Every measurement was therefore stamped with the tracker's own cycle clock, as though it had been observed at the instant it landed. This is the common case, not an exotic one. A field that is decoded and then unused looks identical to a field that is decoded and used , right up until you go looking for its second reference. Here is what that field actually contains, sampled across two consecutive polls of the live feed: reported age of position median 0.31 s p

When a coding agent changes a systems program, a source diff is only the beginning of the question. The more useful question is: what exact machine-facing artifacts would this semantic change produce, and can another process independently verify that relationship? That is one of the research problems we are exploring in SEMAPRAX , an Apache-2.0 agent-native systems programming language built at Wavect GmbH. SEMAPRAX is currently v0.2 pre-alpha experimental research software . It is not production-ready. The narrow mechanism described here is useful precisely because its claims are bounded. From a patch to target projections SEMAPRAX has a read-only command: semaprax target-evidence <file> <patch.spatch> The command takes a verified source snapshot and a semantic patch. It independently rebuilds both the base program and the patched candidate, then derives several deterministic compiler-owned projections: semantic Graph JSON an explicit capability manifest Native C11 source a structurally validated WebAssembly Core module For every projection, the report records a domain-separated digest and byte length. It also classifies the projection as changed or unchanged. That sounds simple, but the distinction matters. A source edit can leave one projection unchanged while altering another. A documentation-level identity change, a capability change, and a runtime-behavior change should not all be flattened into the same “some bytes changed” signal. The target report therefore binds the proposed semantic change to the compiler artifacts it actually affects. Why deterministic output is the prerequisite Evidence over compiler output is only useful when the output is reproducible. SEMAPRAX treats source formatting, semantic graph data, diagnostics, semantic patches, and target artifacts as deterministic projections. The same admitted input must produce the same bytes. Otherwise a digest says little: a second verifier could not distinguish a meaningful change from nondeterministic

Proteger datos que deben seguir siendo secretos dentro de diez años es un problema de hoy : un adversario puede capturar tu tráfico cifrado ahora y descifrarlo cuando exista la capacidad cuántica ( harvest now, decrypt later ). Quipu es una librería libre de cifrado híbrido post-cuántico para datos en reposo: combina criptografía clásica probada con la nueva, de modo que solo se rompe si ambas caen a la vez. Rust puro, y por qué Quipu nació apuntando a varios lenguajes: un núcleo en Rust con una C ABI encima y bindings para Python, Node y Go. Funcionaba, pero la lección fue clara: mantener una interfaz de C estable más cuatro bindings, cada uno con su empaquetado y sus pruebas de interoperabilidad, era complejidad que no pagaba para el objetivo real —proteger datos en reposo— y ampliaba la superficie de ataque con unsafe que no queríamos. Hoy Quipu es Rust puro : memoria segura, sin garbage collector , sin unsafe de primera parte . Y para quien no programa en Rust, se distribuye como rueda nativa de Python (vía PyO3) — que es la superficie que el cliente que no es de Rust de verdad necesita. Una sola base de código, una sola cosa que auditar. Es la misma filosofía que guía el resto: donde hay buena criptografía, se reutiliza; la simplicidad es una decisión de seguridad, no una comodidad. Instalación cargo add quipu # Rust pip install quipu-crypto # Python (rueda nativa, PyO3) Cifrar y descifrar en Python import quipu # Simétrico con contraseña blob = quipu . encrypt_stream ( b " datos sensibles " , " mi-passphrase " ) assert quipu . decrypt_stream ( blob , " mi-passphrase " ) == b " datos sensibles " # Post-cuántico para un destinatario pub , sec = quipu . generate_keypair () # X25519 + ML-KEM-1024 c = quipu . encode_to_recipient ( b " secreto " , pub ) assert quipu . decode_as_recipient ( c , sec ) == b " secreto " Qué hay debajo Cifrado: XChaCha20-Poly1305 (AEAD autenticado). Derivación de claves: Argon2id (resistente a fuerza bruta) + HKDF. Post-cuántico: X25519

The FTC and Zillow have announced a settlement that ends the case alleging that a 2025 "partnership" between Zillow and Redfin violated antitrust laws. The FTC had alleged Zillow agreed to pay Redfin to syndicate its listings, while Redfin would end its own advertising contracts and promise not to compete with Zillow for multifamily listings. […]

When Satoshi Nakamoto designed Bitcoin's Proof-of-Work consensus, the goal was simple: one CPU, one vote. What actually happened was very different. ASIC farms centralized mining into industrial warehouses, and the "one CPU" vision became "one warehouse, one vote." Proof-of-Stake was supposed to fix this by replacing energy expenditure with economic stake. Instead, it created a different problem: the rich get richer, forever. RustChain's Proof-of-Antiquity (PoA) takes a radically different approach. Instead of rewarding who has the most money or the newest hardware, it rewards who has kept the oldest hardware running the longest. The core insight is elegant: time is the one resource that can't be bought, faked, or manufactured. Either your hardware has been alive for twenty years, or it hasn't. This article does a deep technical comparison of Proof-of-Antiquity and Proof-of-Stake, drawing on the actual RustChain source code to explain how each consensus mechanism handles decentralization, Sybil resistance, economic fairness, and network security. The Fundamental Philosophies Proof-of-Stake: Wealth as Security Proof-of-Stake systems — Ethereum 2.0, Cardano, Algorand, Solana (with its Delegated PoS variant) — all share a common assumption: the more tokens you stake, the more committed you are to network security. If you act maliciously, your stake gets slashed. The economic logic is straightforward: attackers would need to acquire a majority of the token supply, which would be prohibitively expensive. The problem is what happens after someone acquires that stake. In PoS, staking rewards compound. A validator with 10x the stake of a small holder earns 10x the rewards, which they can reinvest into more stake. Over time, validator concentration increases. On Ethereum, Lido + Coinbase + Binance + Kraken collectively control over 50% of staked ETH. The "rich get richer" dynamic isn't a bug — it's a mathematical inevitability of proportional rewards based on capital. Proof-

Python is a perfect language for Agile development, where requirements might change on the go. Especially if you are in a startup business, you will need to experiment and change things fast. However, Python is an interpreted language, and in certain situations you might need faster performance than what an interpreted language can provide. A common practice in these cases is using python-to-binary bindings, where the binary code is built with Rust, C++, or Go. In this article, I will explore bindings to Rust-based code. How do the bindings work The idea behind bindings is that you create a module with functions of a specific domain in a language that compiles to binary, and build it as a C-compatible dynamic library ( .so on Linux, .dylib on macOS, .dll on Windows). Then a Python wrapper is built as a Python package and installed together with the dynamic library, allowing you to import and use functions that pass control to the corresponding functions in the dynamic library. On some occasions, classes can be used instead of functions. If any parameters are complex, they must be serialized in the wrapper and passed to the dynamic library as a JSON string or as a set of individual primitive parameters. An experiment with benchmarks To try this Python-Rust communication, I vibe coded an experiment that reads a large CSV file and builds a new one with duplicates stripped out based on specified column indexes. In my test case, it was a 3 MB CSV file with data about European NGOs for the donation platform I am building, where I wanted to remove the NGOs that don't have website URLs listed. As benchmarked, the file was processed 4.3x faster with the Rust binding than directly with Python. Here is the repo to get a first glimpse into the code and structure. What is there to know about Rust A few things about Rust: Rust packages are built with Cargo, which is the equivalent of pip, virtualenv, and setuptools combined. A single package is called a crate, and it can be publi

A chatbot can sound convincing for five minutes without remembering anything. Then you mention the job interview you were stressed about last week, the name of your dog, or a small detail from a late-night conversation. It replies like none of it happened. That is where most "AI companion" demos fall apart. I am building Local Waifu , a desktop AI companion that runs on the user's own Mac or PC. One of the rules I set early was simple: conversations and memories should stay on the machine. No central chat database. No server that needs to be online for the character to remember someone. The rule sounds clean. Building it was not. Saving chats is not memory The first version of memory was the obvious one: save messages. That gives you history, which is useful, but it does not solve recall. A long chat history grows fast. Sending all of it back to a local language model on every message is slow, expensive in context space, and usually makes the reply worse. The model does not need to see every conversation from the last six months. It needs the few pieces that matter right now. If someone says, "I have to take Luna to the vet tomorrow," the character should be able to find that Luna is their dog. It should not need to reread hundreds of unrelated messages about work, movies, and dinner plans to get there. So I treated chat history and long-term memory as different things. Chat history is the recent conversation. It gives the model immediate context. Long-term memory is a small collection of facts, moments, preferences, and relationship details that may matter later. Those memories need to be searchable by meaning, not only by exact words. The memory data stays in SQLite I wanted the app to work without a hosted database, so the storage layer is local SQLite. Each character gets their own data. Chats, memories, extracted entities, and relationships are stored locally on the device. If a user creates two characters, one character does not quietly inherit the other one's

Kintara is a self-hosted document library and reader that runs in Docker and watches a folder you already have. Drop PDFs, Markdown, or text files into the directory and it indexes them automatically, extracts searchable text and metadata, generates thumbnails, and makes the whole library available through a browser or installable PWA. It has libraries, collections, tags, full-text search, highlights, favorites, reading progress, private library sharing, and GitHub OAuth. I have been working on Kintara for a few months, and the architecture actually changed pretty dramatically while I was building it. Kintara originally had a Tauri desktop shell, but I eventually realized that isn't what I wanted at all. So I ripped the desktop layer out and rebuilt it around one Rust server that serves both the API and frontend. Now I can point Kintara at a NAS folder and open the same library from my desktop, laptop, tablet, or phone. The thing I really love about this app is the optional AI features. I added an option to use OpenAI or Gemini, and with so few tokens being spent, it's a fraction of a cent to use most of them, aside from the cover image generation, which is bit more, but makes the library look so much prettier! 😄 Anyway, I wanted AI to be a tool inside the library rather than taking the thing over, and I wanted it to be fully optional, so if you're one of those "Ew, AI is in this app" people, you just don't turn it on and it's like it doesn't exist. What the AI can do is summarize documents, suggest metadata and fill in those blank spaces, generate cover images for docs that don't have a cover, search the library for docs, or you can just chat with it about your docs. Find is a pretty great AI feature I think. Instead of letting the model vaguely tell you that something appears "somewhere in the document," Kintara asks for actual passages with page numbers, verifies the quote against extracted page text on the server, then verifies it again against the rendered PDF.

At the first step, I picked up the SurrealDB project for contribution. I didn't know how I could help this project become better. So I asked my beautiful OpenCode to find parts of the project that could be better. It suggested this file of the project(core/src/val/value/get.rs) to me and said it has a double-cloning issue. So I opened up VS Code, and I started checking the issue. The code was something like this: let mut a = Vec :: new (); for v in v .iter () { let cur = v .clone () .into (); if stk .run (| stk | w .compute ( stk , ctx , opt , Some ( & cur ))) .await .catch_return () ? .is_truthy () { a .push ( v .clone ()); } } First Optimization: As you can see at line 3 and line 9, we have multiple clones from a single document. I thought about how I could fix this issue; I went to see the CursorDoc structure because the first clone is converted to it: #[derive(Clone, Debug)] pub ( crate ) struct CursorDoc { pub ( crate ) rid : Option < Arc < RecordId >> , pub ( crate ) ir : Option < Arc < IteratorRecord >> , pub ( crate ) doc : CursorRecord , pub ( crate ) fields_computed : bool , } impl From < Value > for CursorDoc { fn from ( val : Value ) -> Self { Self { rid : None , ir : None , doc : val .into (), fields_computed : false , } } } #[derive(Clone, Debug)] pub ( crate ) struct CursorRecord { /// The underlying record, shared via Arc for copy-on-write record : Arc < Record > , } impl CursorRecord { // .... // /// cloning. Otherwise the value is cloned. pub ( crate ) fn into_owned ( self ) -> Value { match Arc :: try_unwrap ( self .record ) { Ok ( record ) => record .data , Err ( arc ) => arc .data .clone (), } } // .... // } impl From < Value > for CursorRecord { fn from ( value : Value ) -> Self { Self { record : Arc :: new ( Record :: new ( value )), } } } I saw that the value passed through CursorDoc is directly stored in a field in CursorRecord without any changes, and it is accessible using .into_owned() from CursorRecord. That is the solution; I edited the

VoidZero has launched the beta of Vite+, a unified web development toolchain. It combines runtime, package management, and essential frontend tools under a single command. Vite+ supports various projects and is open source. The platform enhances workflow through features such as hot-reloading, format checking, and testing. The team emphasizes community feedback for future updates. By Daniel Curtis

GitHub热门项目 | Developer Control Plane for your AI Agents | Stars: 5,332 | 64 stars today | 语言: Rust

Mark (aka Winsaucerer) here to show you how you can test your PostgreSQL database like a sorcerer. We are going to be using Spawn, a SQL build system supporting migrations and testing. You do not need to be using Spawn for migrations in order to use it for testing. Spawn does not require any extension installed. All you need is the spawn CLI and a psql connection to the database for Spawn to connect through. Spawn was built to solve some migration pains I've experienced, but I happily discovered that when used for testing, it is very powerful. To show you some of that power, we're going to use a contrived database example. It uses golden file testing to determine success. When the test runs, we capture the stdout and stderr output from psql, and compare that to expected output. Testing with Spawn involves these steps: Create a new test with spawn test new <name> and fill out the test steps Check test outputs with spawn test run <name> (or view the SQL that will be sent to psql via spawn test build <name> ) When outputs are as expected, create the golden file with spawn test expect <name> Run the test and compare to expected output with spawn test compare <name> For now, Spawn only supports connecting via psql, which means that you have access to all the features that psql provides. To get started, follow the Spawn install instructions: Install Spawn And then create a new folder on your system, and initialise a new project with a docker compose config ready for us to play with: # inside your new folder: spawn init --docker docker compose up -d You now have a running docker based PostgreSQL database and a spawn.toml file configured to connect to it. We are not assuming that you are using Spawn or any other tool for migrations, so you can manually create and update the database by connecting directly using psql: docker exec -ti postgres-db psql -U postgres Create the database ⚠️ Caution This post is not intended as an example of how to build an orders database. The des

Originally published on tamiz.pro . The Silent Crisis: Undefined Behavior Across Language Boundaries Recent high-profile security incidents have exposed a growing concern in the software engineering world: undefined behavior (UB) is not just a C/C++ problem anymore. From Rust compilation bugs to JavaScript engine vulnerabilities, developers are witnessing how subtle language design choices can lead to catastrophic failures when code crosses language boundaries or interacts with low-level systems. These incidents aren't isolated — they represent a systemic issue affecting modern software stacks built on heterogeneous language ecosystems. Case Study: The Rust Memory Safety Myth Rust was built with the promise of memory safety without garbage collection. Yet, recent CVEs have revealed that undefined behavior in unsafe Rust blocks can compromise entire systems: The 2024 OpenSSL Rust Port Incident A critical vulnerability was discovered in a Rust port of OpenSSL where unsafe code blocks performed unchecked pointer arithmetic. While the safe Rust layer enforced bounds checking, the unsafe boundary passed raw pointers to the C layer without validation. // Vulnerable pattern discovered in the incident unsafe { let ptr = slice .as_mut_ptr (); // No bounds check - undefined if offset exceeds slice length let unsafe_slice = std :: slice :: from_raw_parts_mut ( ptr , len + offset ); } This wasn't caught by Rust's compiler because it explicitly allows unsafe operations. The UB only manifested during cross-language calls to the underlying C library. The WebAssembly Compilation Bug Another incident involved a Rust-to-Wasm compilation bug where the compiler optimized away what should have been defensive checks, assuming the guarantees of safe Rust would hold at runtime. When these assumptions broke at the Wasm boundary, attackers could trigger heap overflows. JavaScript's Hidden Undefined Behavior While JavaScript is often criticized for loose typing, its recent security incidents

GitHub热门项目 | Secure and fast microVMs for serverless computing. | Stars: 36,167 | 31 stars today | 语言: Rust

GitHub热门项目 | 企业微信开放平台命令行工具 — 让人类和 AI Agent 都能在终端中操作企业微信 | Stars: 2,898 | 34 stars today | 语言: Rust

I love writing in Markdown. What I don't love is opening a 200MB+ Electron app just to jot down a note. So I built Markify - a desktop Markdown editor that weighs in at under 10MB and still ships a real feature set. Why bother Obsidian is great, but it's heavy, and most of what I actually need day-to-day is simpler: open a file, write, preview, export, done. Every "lightweight" alternative I tried either wasn't actually light, or was missing basics like PDF export or a proper file explorer. So I built the tool I wanted. What's in it Open & save .md , .markdown , .mdx files with native dialogs Sidebar file explorer - browse a whole folder, expand subfolders on demand, just like VS Code Three view modes : Read, Edit, and Hybrid (live side-by-side preview) PDF export with embedded images and proper Unicode font handling Light/dark theme that follows your system in real time 4 languages out of the box: English, French, German, Spanish Native title bar per platform (real traffic lights on macOS, custom controls on Windows/Linux) The stack Angular 22 (with Signals) on the frontend, Rust on the backend, glued together with Tauri 2 . That combo is exactly why the app stays small - no bundled Chromium, no Node runtime shipped, just the OS's native webview. 82 unit tests (Vitest) keep the core services honest. Everything is open source, AGPL-3.0: github.com/Martzcode/Markify Markdown is basically AI's native language now Here's the other reason this project felt worth building right now: every LLM defaults to Markdown. Ask ChatGPT, Claude, or Copilot for anything structured and you get headers, bullet lists, code fences, bold text - Markdown, every time. It's become the de facto output format for AI because it's plain text, unambiguous to parse, and renders cleanly almost everywhere. That shift changes what a Markdown editor needs to be good at: Copy-pasting AI output should just work - no reformatting, no broken tables, no mangled code blocks Code block rendering with copy b

This is a writeup of building a required CI gate for degraded-network behavior. The system under test is a robotics fleet substrate, but the finding applies to anyone shaping networks in CI. Ganglion exists to reach robots on networks nobody controls. Warehouse Wi-Fi, carrier CGNAT, a hospital VLAN, a customer firewall that was configured once in 2019 and has not been touched since. Until this week that claim was a sentence on a website. CI ran on clean loopback, everything was green, and the failure modes that actually matter in the field were the exact ones the test suite could never produce. That is now a required gate. Every push to main runs the full deploy, invoke and verify round trip over the relay against five shaped network profiles, and all five have to pass before anything merges. I build Ganglion, so treat the enthusiasm accordingly. The part worth your time is not that it went green. It is what I got wrong on the way there. The five profiles clean : baseline, no shaping. If this one fails, something else is broken. lossy : packet loss with light reordering. high-latency : 250ms round trip. asymmetric : plentiful downlink, starved uplink. This is the one nobody tests and the one teleop actually dies on, because control acknowledgements go the starved direction. nat-relay : endpoints with no route to each other at all, forcing hole punching to fail and relay fallback to carry the session. The last two are the ones I care about. Loss and latency are what people imagine a bad network is. Asymmetry and no-direct-route are what a bad network usually is. What I got wrong The original design assumed you can pin netem's seed and get a repeatable lossy run. Two profiles: a pinned-seed one that gates the build, and a nastier randomized one that runs nightly and is allowed to fail. You cannot pin netem's seed. Its loss and jitter draw from the kernel RNG and there is no seed parameter to set. A "deterministic lossy netem profile" is not a thing that exists. This m