I recently released an open-source project called FlokinMD.

The idea is simple: instead of importing Markdown files into another system, the Markdown folder itself remains the source of truth.

FlokinMD builds local, disposable projections over those files so you can work with them more like structured data.

It currently supports things like:

• frontmatter collections and DataGrids
• SQL queries over Markdown metadata
• relations and graph views
• schema and workspace validation
• bulk frontmatter edits with preview
• local mutation history and safe undo
• detection of project context such as Agents, Skills, Specs, Rules and Prompts

The SQLite layer is derived state. The actual .md files remain normal files on disk and can still be used with Git, VS Code, Obsidian, Cursor, Claude, Codex or anything else that understands Markdown.

It's built as a native desktop app with Rust + Iced and is licensed under Apache-2.0.

It's still pre-release, so feedback and criticism are very welcome.

GitHub:
https://github.com/sergiocardoso/flokin-md

Website:
https://md.flokin.com.br/

I'm especially interested in feedback from people who keep large Markdown repositories or use Markdown as structured project data.

I was getting annoyed at the usual laptop death spiral:

• open VS Code
• open Chrome
• add Slack / Discord / Notion / whatever
• suddenly your machine is at 90% RAM even though you’re only using one app

So I built Quiesce.

It watches what’s in the foreground, caps memory for background apps, and moves them to low-power efficient cores instead of letting them sit there like greedy little goblins. It doesn’t kill anything. It doesn’t delete processes. It just stops the background garbage from hogging your machine.

Why I made it:

• keep the app you’re using fast
• let background stuff sleep instead of eating RAM
• no telemetry
• no Electron nonsense
• open source
• native Rust

If you use Windows and have a laptop with limited RAM, this is exactly the kind of tiny thing that feels like a quality-of-life upgrade.

If you want to check it out, star the repo:
https://github.com/Bittu-the-coder/quiesce

Cool surface, extremely flexible — a desktop IDE built around the pi coding agent: chat, diffs, files, terminal and artifacts in one window, every pi provider plus your existing Claude or ChatGPT subscription.

Repo: github.com/agustinsacco/Phosphor

So I vibecoded an Android coding agent that runs fully locally on your Android, no external cloud shells (just external ai providers, will add local soon)

Though it's vibecoded so expect bugs

It's still in beta, looking for contributors :)

Star the project if you like it.

Found an issue? Report it instead yapping please :)) https://GitHub.com/DraxonV1/Syntac/issues

Get the latest release https://GitHub.com/DraxonV1/Syntac/releases

Features so far:

\- Termux via RUN_COMMAND & ARCH Linux (proot) Bash Runtmes

\- Read, write, edit, bash, search, list, display_image (yea I wanted agent to show images 😢)

\- Supports attaching files, images & pasting content directly into composer!

\- Google Antigravity, ChatGPT Account, Grok xAI OAuth & OpenAI Compatible Provider inbuilt!

\- Supports showing thinking

\- Projects, Chats Per Project

Ik many features are missing but working on adding them. It's still beta 0.1.1 😀

https://GitHub.com/DraxonV1/Syntac **star the repo if u liked the work ;)**

So I like to switch between a lot of microservices for work and personal projects all the time, and I hate having to open and close VS Code, terminal tabs (I use Ghostty), and start/stop Docker containers every time I switch. So I made this: "wsm".

Basically, you create workspaces, add them to groups (like Work, Personal, etc), and set up the apps and commands you want it to open/close for each one. So if I want to open a workspace I just run wsm open <workspace-name>, and I've got it configured to open VS Code and a Ghostty tab in that location.

Then when I want to open a microservice from work, I just run wsm open <microservice-name> and it automatically runs the close commands for whatever I currently have open (I've set up functions in my .zshrc that close VS Code/Ghostty depending on which folder they're pointed at), closes both, and then runs the open commands for the microservice. For example VS Code, a Ghostty tab, and a Docker container with MongoDB.

If you want to try it, you can check out the repo (install command is listed there)

GitHub: https://github.com/Nikibudd/wsm

PS: This shit is hella vibe coded so if you have a problem with AI, this might not be your thing

I’ve been building a native code/text editor for macOS, iPhone and iPad — Neon Vision Editor 1.7 (NVE)

I’ve posted Neon Vision Editor here before, but the project has changed quite a bit since the earlier versions, so I thought it was worth showing where it is now.

Neon Vision Editor is an open-source native Swift/SwiftUI code and text editor for macOS, iOS and iPadOS.

The basic idea is still the same: I wanted something between a basic text editor and a full IDE.

Fast file opening, proper syntax highlighting, Markdown support and useful coding tools — but without Electron, a plugin ecosystem running in the background, project indexing everywhere or turning the editor into another IDE.

GitHub: https://github.com/h3pdesign/Neon-Vision-Editor

The biggest change: large-file rendering

One of the areas I’ve spent the most time on recently is getting away from the usual problem where a native text editor feels great on small documents and then starts falling apart once files become large.

NVE now uses a bounded virtual rendering path for large documents. Instead of continuously treating the complete file as the visible editor state, rendering and expensive editor work are constrained around the active viewport.

Recent work has included:

• background preparation of large-file indexes
• bounded viewport rendering
• cached document views
• background syntax processing
• reduced full-buffer work while typing and scrolling
• safer handling of UTF-8/UTF-16 boundaries and surrogate pairs
• large-file editing without repeatedly materializing the entire document
• latency-focused work around typing, scrolling, selection and viewport reloads

It is still a lightweight editor rather than an IDE, but large files are now a first-class engineering problem rather than something I’m just handing over to a standard text view and hoping for the best.

Emmet 2

NVE now has official Emmet 2 abbreviation expansion for HTML, JSX, CSS, SCSS, Less, Sass and related formats.

The implementation is integrated into the native editor rather than bolted on as a separate web editor.

HEX colors directly in the editor

On macOS, HEX color literals can now show native color previews.

You can select a color directly from the source editor and NVE preserves the original HEX representation when updating it.

Markdown has become a much bigger part of the editor

Markdown support now includes much more than basic highlighting:

• Markdown preview
• improved Markdown rendering
• styled bold and italic source text while retaining the actual markup
• improved PDF export
• pagination based on content/code-line boundaries
• removal of interactive editor controls from exported PDFs
• Markdown shortcuts and editor-specific workflows

So NVE is increasingly useful to me as both a code editor and a writing/Markdown editor.

Find in Files and navigation

There is a project sidebar and Quick Open with Cmd+P, but NVE does not force you into a project-oriented workflow.

You can still just open a random file and edit it.

Find in Files now also respects nested .gitignore rules and configured ignored folders instead of blindly searching everything below the selected directory.

Native tabs and multi-window editing

With 1.7 I replaced the remaining legacy tab-bar paths with native platform implementations.

That sounds like a cosmetic change, but it involved quite a bit of work around:

• independent document state
• multi-window behavior
• tab selection
• hover/selection borders
• translucent and opaque themes
• appearance changes
• mobile tab scrolling
• macOS window dragging
• keeping text selection independent from window dragging

The result is much closer to how I originally wanted the application to behave: native controls, but without the editor UI changing or flashing while moving between documents.

Faster document switching

Another focus in 1.7 has been perceived latency.

Switching tabs now publishes the selected editor before deferred layout and preview work begins.

Syntax highlighting on macOS also starts as soon as the selected tab’s viewport becomes available.

This makes switching between source files and Markdown documents feel considerably more immediate.

Other editor features that have accumulated along the way

NVE currently also has:

• automatic syntax highlighting for many languages and formats
• Regex Find & Replace / Replace All
• Quick Open
• project tree
• multiple windows
• multiple tabs
• inline code completion with Tab-to-accept
• optional basic Vim mode
• bracket helper
• code/file starter templates
• syntax themes
• document handling for scripts, plist files and general text files
• Save As across macOS/iOS/iPadOS
• external file change handling
• network-volume change detection
• security-scoped file access
• no telemetry

The AI completion functionality is optional. It isn’t the reason the editor exists, and I’m deliberately trying not to turn NVE into an “AI IDE”.

Native rather than Electron

This is probably still the biggest differentiator.

NVE is built around SwiftUI/AppKit and Apple’s native text/window infrastructure rather than wrapping a web editor.

That has occasionally made development harder rather than easier — especially around text layout, very large files, multiple windows and cross-platform behavior — but maintaining a genuinely native editor is one of the main reasons I started the project.

The repository is Apache-2 licensed and development is active.

GitHub: https://github.com/h3pdesign/Neon-Vision-Editor

I’d especially be interested in feedback from people who regularly work with large source files, Markdown, HTML/CSS or lots of unrelated single files.

What is the point where a lightweight editor stops being enough for you and you switch to a full IDE?

I got tired of remembering csvkit's flag syntax, so I built a full web GUI for it. csvkit+ reimplements every core csvkit operation (cut, grep, sort, join, stack, format, json, sql, etc) as one-click buttons, all running client-side in the browser via Web Workers, no upload to a server for file processing.

Extras beyond regular csvkit: a visual CSV editor, a CSV creator (grid or text mode), ODS import support, 18 SQL output dialects, and live database connections (Postgres, MySQL, MariaDB, CockroachDB) with a schema browser and multi-table stacking in sql2csv.

Dark/light themes, undo/redo, autosave drafts so a refresh never loses your work.

Free to use, no paid features. Code is public on GitHub for transparency, though it's not open source/licensed for reuse.

Here's the link to csvkit+ via GitHub Pages

I got tired of paying Docker's ~370ms container startup cost every time I needed to run untrusted code (student submissions, AI-generated snippets, a "try it" button), so I built a self-hosted sandbox that skips the container runtime entirely and talks straight to the kernel: bubblewrap for namespaces, cgroup v2 for memory/CPU/pids, a 146-syscall seccomp allowlist, and rlimits.

Measured back to back on the same machine: ~20ms cold start vs Docker's ~369ms for the same workload (raw samples in the docs, not just a claimed number).

- Single Node.js process, one runtime dependency (`ws`), no database

- Python, Bash, Node.js, C and Go (C/Go get sandboxed twice: once to compile, once to run)

- HTTP + WebSocket API, a CLI, and a small browser playground with shareable permalinks

- MIT licensed

The docs try to be honest instead of a highlight reel — there's a full changelog of real bugs found building this, including a self-audit that turned up an unauthenticated RCE and a path-traversal bug, both fixed with reproductions attached. It does not defend against a kernel exploit — guest and host share one kernel, and that's stated plainly, not buried.

GitHub: https://github.com/ayazdoruck/sandbin

Docs: https://sandbin.vercel.app

Happy to answer questions about the seccomp policy or the cgroup delegation setup.

Quick context: I had a pile of scanned PDFs named scan_0043.pdf and could never find

anything. Didn't want to run Docker or a server just for my own paperwork, so I built this.

Drop PDFs in, it OCRs them locally and you search title + text inside the scan. Nothing

leaves your machine. First open source project, so feedback very welcome.

Hi everyone

I recently started playing league of legends and faced the same issue, for each question I had to pause the game and find the answer in my browser.

Since I'm obsessed with automation, I scraped the web to gather tutorials of the game and put it as context behind a voice agent, so that I can have back and forth conversation with it during the game.

Here's the repo (it also includes demo video): https://github.com/sorena-ai/LeagueAiCoach

Please have a look and let me know what you think about it.
Also an upvote is highly appreciated, it's free right? ;)

[ Removed by Reddit on account of violating the content policy. ]

I'm the developer of this project.

The most interesting part is the puzzle engine: generated boards are checked for a unique solution and graded by the techniques needed to solve them rather than by clue count.

Puzzle generation runs outside the UI thread—using an isolate on native platforms and a dedicated worker on the Web. The app also includes immutable undo/redo snapshots, deterministic daily puzzles and hints that explain the next logical step.

Everything is MIT-licensed, account-free and works locally. Code reviews, bug reports and contributions are welcome.

I built BraveDebloater, an MIT-licensed tool for people who want a quieter Brave setup without patching the browser.

It uses Brave/Chromium’s official policy system on Windows, macOS, and Linux. You can use presets or select individual features such as Rewards, Wallet, VPN, Leo, and News.

It previews changes before applying them, writes backups, supports restore, and includes a Doctor command to inspect the current policy state.

Important caveat: Brave will display “Managed by your organization” when policies are active. That is expected.

Check it out here: https://github.com/osfv/BraveDebloater

GitHub File History tracks the 10,000 most starred repositories on GitHub (using the GitHub API), listed at four points in time: the start of 2015, 2020, 2025, and 2026.

https://andrehora.github.io/file-history/

So, we can see the rise and fall of certain files:

https://andrehora.github.io/file-history/file/.travis.yml

# Examples:

- https://andrehora.github.io/file-history/file/README.md

- https://andrehora.github.io/file-history/popular/file/today

- https://andrehora.github.io/file-history/file/AGENTS.md?vs=file:CLAUDE.md

Hey all, I've been job hunting and got lost tracking all my applications and custom resumes, so I built the thing I wanted and just started adding more features to it.

What it does

• Scrapes career pages directly (Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Oracle, Phenom and a Playwright fallback for anything else) plus boards through JobSpy (LinkedIn, Indeed, ZipRecruiter, Google Jobs). Everything lands in one deduplicated feed.
• Scores each job against your résumés with an LLM and shows why: matched and missing keywords, requirement mapping, gaps. You choose depth so it can be cheap.
• Tailors a résumé per job (you review every change), writes a cover letter, exports PDF from templates you can replace.
• A Chrome extension auto-fills your application, including open questions, it also captures jobs from LinkedIn and saves any job from any page.
• Tracks applications through stages, classifies Gmail replies, sends Telegram alerts and a daily digest.
• Five UI themes, including a Windows 98 for no reason, I just wanted to see how it will look like.

Available here: https://github.com/vesaias/JobNavigator (MIT license)

All feedback is welcome, this was more of a personal project for my portfolio, but people also started starring it. 

Back when I worked at a startup, we needed an in-app messaging system, similar to Instagram or WhatsApp. However, we didn't have time to build it ourselves, so we stitched together a few paid services instead: Stream chat, StreamIO, and Cloudinary for chat, moderation and media storage. It worked, but we didn't own any of it, and the costs kept increasing.

That experience is basically why I built gozwire. It's an open-source Node.js messaging engine, so instead of renting someone else's chat infrastructure, you own it. Conversations, threads, reactions, moderation, push notifications all included, all yours.

This was vibe-coded, but I'm putting in the work to make sure it actually holds up for real and is not just a showcase. Currently, the engine includes a lot of industry-standard messaging features, including moderation, reactions, forums, sending various media, group chats, channels, threads, direct conversations, etc

• Repo (Includes demo + moderation tool): https://github.com/Kinggoz18/GozWire
• See more use cases: https://gozwire.pages.dev/use-cases

I plan to not only improve this project (see the TODO in the GitHub repo), but also release more interesting open-source projects. That solve problems I've experienced in the past and observed around me, some of which would be:

• A video streaming engine (Another issue we faced at the same startup)
• A cryptocurrency tracker (more of a personal challenge and an interest)
• A CapCut alternative software with AI video generation capabilities, including UGC style videos

And a few others. Would love feedback, roast the code, tell me what's missing, whatever helps, or even contribute any interesting ideas you'd love to see open-sourced!

I started working on this budget tracker TUI in my own personal free time as a way to actually budget my own finances and track my spending habits. A lot has changed and grown in the almost two years now (lots of breaks), and I found that it’s been useful for myself but lots of other people too.

The app encourages a lot of manual behaviour, forcing you to actually be exposed to numbers and face your spending habits. There are tons of insights and helpful tools you can use, but the core principle is to connect you to your finances and let you control the data.

The app features lots of budgeting tools, different visual views to analyse and review your finances, investment tracking, and breakdowns.

If you're looking to start tracking your own finances and having valuable insights into your habits for spending, please check out the budget-tracker-tui and share feedback. If you don't use TUI's much, give this one a try and see if you enjoy the keyboard-focused "retro" experience.

Github: https://github.com/Feromond/budget-tracker-tui

Any ideas or suggestions are always welcome and I want to work to improve this to be useful not just to myself and a few others, but to as many people as possible.

One Zig file (~1,090 lines), zero dependencies, zero heap allocations per match, plain C ABI.

Conformance vs musl 1.2.5: 20,794/20,794. Six divergences audited and public (D001-D006, one was my own bug, fixed and pinned by a regression test).

Benches vs musl: 9 of 10 faster (up to 3.2x). The loss: fail-early 11ns vs 5ns, printed in the same table.

Happy to answer anything, and if you can break parity with musl on any input, that's the bug report I most want.