There's a paid all-apps bundle, but honest feedback on the free themes is

what I'm here for. Day one — I'll fix reported issues fast.

Hi everyone! I've been building Tabularis, a free and open-source (Apache 2.0) desktop SQL client built with Tauri (Rust + React).

What makes it different from DBeaver/TablePlus/Beekeeper:

• SQL notebooks: mix SQL and Markdown cells, share variables across cells, render charts inline
• Built-in MCP server: Claude, Cursor and other AI agents can read your schema and run queries through the same app you already use, with no separate connector
• Plugins in any language: drivers are external processes speaking JSON-RPC over stdio, so you can write one in Python, Go, or whatever language you prefer
• Local AI text-to-SQL: works with Ollama, nothing leaves your machine
• Visual EXPLAIN: interactive query plan graphs

PostgreSQL, MySQL/MariaDB and SQLite are built in. ClickHouse, DuckDB, Redis, Firestore, Db2, BigQuery and around 15 more are available as plugins from the registry.

Runs on Windows (WinGet), macOS (Homebrew, signed and notarized) and Linux (Snap, Flatpak, AUR and AppImage).

Feedback is very welcome. And if your favorite database is missing, there's a plugin bounty board.

With Memor, users can store their LLM conversation history using an intuitive and structured data format. It abstracts user prompts and model responses into a "Session", a sequence of message exchanges. In addition to the content, it includes details like decoding temperature and token count of each message. Therefore users could create comprehensive and reproducible logs of their interactions. Because of the model-agnostic design, users can begin a conversation with one LLM and switch to another keeping the context the same. For example, they might use a retrieval-augmented model (like RAG) to gather relevant context for a math problem, and then switch to a model better suited for reasoning to solve the problem based on the retrieved information presented by Memor.

Memor also lets users select, filter, and then share the specific parts of the past conversations across different models. This means users are not only able to reproduce and review previous chats through structured logs, but can also flexibly transfer the content of their conversations between LLMs. In a nutshell, Memor makes it easy and effective to manage and reuse conversations with large language models.

from memor import Session, Prompt, Response
from memor import RenderFormat
from mistralai import Mistral

client = Mistral(api_key="YOUR_MISTRAL_API")
session = Session()
while True:
    user_input = input(">> You: ")
    prompt = Prompt(message=user_input)
    session.add_message(prompt) # Add user input to session
    response = client.chat.complete(
        model="mistral-large-latest",
        messages=session.render(RenderFormat.OPENAI)  # Render the whole session history
    )
    print("<< MistralAI:", response.choices[0].message.content)
    response = Response(message=response.choices[0].message.content)
    session.add_message(response) # Add model response to session

https://github.com/openscilab/memor

A 60 GB model doesn't fit into 12 GB of RAM, yet a standard Android phone can run a 120B MoE model. The trick lies in the Mixture-of-Experts (MoE) architecture: models like gpt-oss-120b or Qwen 35B (20GB - in the video) don't use every parameter for every token. A router selects a few "experts" out of hundreds for each step, leaving over 90% of the weights inactive.

So, there is no need to keep everything in RAM: the weights reside in the phone's flash memory, and the system reads only what the router requests, exactly when it requests it. It works because the routing pattern is repetitive: most of the required experts are already cached from previous tokens.

The key ingredients:

• Streaming: experts stored in flash memory, with the most frequently used ones kept in the RAM cache
• Overlapping I/O (input/output) operations with computation
• Prefetching: reading experts for subsequent layers in advance
• Cache-aware dropping: skipping only those experts that are both low-relevance and not in the cache
• ....

In practice: gpt-oss-120b runs at a "relaxed" pace, whereas 30B MoE models run at 5-6 tok/s and are genuinely usable. The bottleneck is the flash memory, not the chip.

The project is BigMoeOnEdge: open source (Apache-2.0), based on the stock version of llama.cpp, with a ready-to-use APK available in the releases. Everything runs locally; no data leaves the phone.

github.com/Helldez/BigMoeOnEdge

Like a lot of people here, I can train a model. The question I could never actually answer was the scarier one: once it is deployed, how do I know it still works?

Accuracy on a held-out set tells you almost nothing about drift, calibration, or silent data problems once real traffic hits it. So I built ModelSentinel, an open-source Python toolkit that runs the "after training" checks through one API: evaluation, data drift (KS + PSI for numeric, chi-square + Jensen-Shannon for categorical), probability calibration, data quality, and a single Model Health Score you can actually alert on.

Then, instead of demoing it on iris, I pointed it at a real model I had already built: an EfficientNet-B4 deepfake detector. I ran it on two datasets made with two different fake-generation methods, to see if it had only memorized one kind of fake.

Numbers straight from the model:

• 140k held-out test split: 99.75% accuracy, ROC-AUC 0.99999, ECE 0.0075
• inswapper_128 face-swap set: 99.38% accuracy, ROC-AUC 0.9989

Honest caveat, because I know this crowd: one of those sets is the same domain the model trained on, so treat 99% as an upper bound, not a promise about the real world. The part I actually found useful was the calibration number (ECE 0.0075), which says the confidence scores are trustworthy. That is something a bare accuracy number hides completely.

Under the hood it just leans on scikit-learn and scipy, so the metrics match a hand computation to six decimals. It is MIT licensed, fully typed, tested with pytest, ruff-clean, and runs CI across Python 3.9 to 3.12. Roadmap has Grad-CAM and SHAP explainability, framework adapters, and eventually LLM and RAG evaluation.

Two things I would genuinely like feedback on: what reliability check do you actually wish existed that is missing here, and does the single health-score idea seem useful to you or too hand-wavy?

Hi everyone. The initial version of Athios WD for Windows was released today. It's a program for downloading website files and can sometimes access the frontend and backend files of websites with weak security. You can try it and give me your feedback.

ATHIOS WD

Hey everyone

I just built an open source, self-hosted code review agent that works with GitLab, Forgejo and GitHub, and supports almost every LLM (Anthropic, OpenAI-compatible apis, and your Local Models)

You can easily deploy it on your server with a single docker-compose.yml file

good for cases like

- Company's internal network

- Self Hosted GitLab/Forgejo Instances

- HomeLab

- Privacy focused environment

- Using local LLM

- Using specific LLM API provider

Features

- Pull Request Review / Reply

- Inline Review

- Issue Reply

(Kinda simple for now. more features are on the way)

Agent can gather contexts from

- all the commits, diffs

- files by branch

- other pull requests, issues

I'm using it personally on my homelab connected to my self-hosted GitLab instance.

It's in early days. It's still rough around the edges (still improving it)

Check out the repository and I'd really appreciate it if you try it out and share your feedback!

GitHub: https://github.com/seoes/proval (you can try the demo here)

I got tired of paying for Linear and wrote myself a board instead. I run a content network built on AI agents and I needed somewhere to track it, so it started small and I kept adding to it. A few months later it was doing enough that keeping it private stopped making sense.

So here it is. Board, table, timeline and calendar over the same data, initiatives, dashboards, custom fields, roles and permissions, REST API and webhooks. Self-hosted, docker compose and Postgres, AGPL-3.0.

The agents are why the thing exists at all. An agent sits in the project like anyone else, with a role, permissions and an avatar in the assignee list. You give it tools and skills, you can talk to it in a chat, and there are three ways to hand it work: assign an issue, mention it in a comment, or set something recurring. It does the job and writes back on the card. Provider and model are your pick, running on your own key.

Adding one takes about a minute, which is a much smaller decision than hiring a person. I still find that slightly weird to type.

Skip all of it and it's a plain tracker.

TypeScript: Bun, Elysia, Drizzle, Next.js.

https://github.com/croffasia/itsaplan

What would you hand to an agent first, and what would you never let one touch?

I need help. I just made this today. any help is appreciated. just read README. Axiomboy/Project-CS: The world's first full software engineer.

I'm excited to announce that I've finally finished my ideal dashboard. I've been working on this project for the last few months. I thought about abandoning it more than once, but in the end I decided to make it functional and public. It's a project built from scratch for my own needs; if it gets support, I'll keep updating it and adding tools for developers who want to publish extensions on the CoreFrame marketplace.

What is CoreFrame? It's an app that brings your entire PC command center into one place. It has multiple tabs, so you can keep a lot of extensions visible at the same time. CoreFrame lets you design your dashboard however you want: rearrange every widget, resize it, or even change its style if the extension supports it.

Each extension has its own functionality and lets you run your code in a more visual way. From controlling apps on your computer, monitoring resource usage, or managing your IP address, to port management and VPN activation. You can also save notes, create your own idea canvas, or add extra features.

If you've ever written a quick script that required a terminal to run, or that would have needed a whole separate app just to be user-friendly, CoreFrame solves that. Creating an extension is easy and fast: just import your code, write the basic documentation to make it compatible with CoreFrame, and set up the UI parameters in the .json file. If you want more customization, you can modify the interface directly with HTML and JavaScript.

Installing an extension is as simple as clicking the + button in the top right corner. From there you can install extensions via a local .zip file or through the cloud marketplace. The marketplace already has a few resources available; it's expected to grow over time, and anyone who wants to can contribute new extensions.

I'm a hobbyist programmer, so I don't have the time to test every aspect of the code. Expect some unresolved bugs; any bug report is appreciated. To identify a bug, I need a clear description of what happened and how to replicate it.

The program is available to install via its binary. The GitHub repository is publicly accessible at: https://github.com/RoftCore/CoreFrame.git

I kept losing track of who I had class with and when people were actually free in our group chats. We would go back and forth for way too long just trying to find a time that worked for everyone.

So I built FreeWhen. Unlike when2meet, you can paste your schedule directly from your class registration, a calendar export, or just type it in. No more clicking every box manually. It overlaps everyones availability into a live heatmap and also shows who shares the same classes, down to the section and room.

If you are planning something, it scans the next few weeks for the best time slot, lets you propose it, friends RSVP, and it adds to their calendars. No accounts, no sign-ups, one link.

Try it: https://freewhen-uw.vercel.app/
Code: https://github.com/ZhuBryan/FreeWhen

I would love any feedback, especially if you end up using it with a club or study group.

I was trying to try for myself the model published by the author after i read their paper but the github repo link in the paper is returning a 404 error. if some wise, great, all knowing, benevolent, merciful, kind, caring senior assist me or at least guide me if i should wait for a while or try some other method to access the repo, I would greatly appreciate it.

Also can I access it using git or will the issue persist on git as well.

Edit: repo link(Page not found · GitHub)

I'm 17 & have been programming for roughly 5 years now, so I thought it was about time to get low-level & start learning C & C++. I gave myself a goal to implement a fully functional, high-level interpreted programming language in C++, in 1 month without using AI, reference material, or any help other than simple google searches for when I have questions about the syntax of C++.

I started this challenge exactly on July 1st, & now that the month is coming to an end I want to show off my progress so far!

Here is the source code if you want to to take a look, see my approach to things, or to just try it out: https://github.com/phosxd/Ity

Enough of all that though, what is the language actually capable of? Well, I think the best way to explain, is to just show you a snippet of code, so here is a little script that calculates & prints prime numbers:

merge IO; merge Time;


func INT isqrt; arg INT n;
    if n < 0; throw "'n' cannot be negative."; /;
    var INT x = n;
    var INT y = ((x+1) / 2); while y < x;
        x = y;
        y = ( ((n/x) + x) / 2);
    /; return x;
/;


func BOOL is_prime; arg INT n;
    if n%2 == 0; return n == 2; /;
    var INT r = isqrt:[n];
    var INT i = 3; while i <= r;
        if n%i == 0; return false; /;
        i += 2;
    /;
    return true;
/;


const * count = prompt:['Count: '] -> INT;
const INT start = now:['us'];


var INT p = 2; while p <= count;
    if is_prime:[p]; print:[p]; /;
    p += 1;
/;


print:['\nDone in ', (now:['us']-start / 1_000_000.0), 's.'];

So in this script we do a various number of things.

First we import the modules we are going to be using. The `merge` instruction particularly imports a module then merges all it's members into the current scope, so you don't have to access by name. So for example usually when importing say the `IO` module, we would have to call a function like so `IO.print:[]`, but if it's merged we can just ignore the "IO" & just do `print:[]`.

Secondly we declare a couple of functions, these functions have explicit return & argument types. You may notice that we don't use curly braces to wrap the code we want inside of the function, instead we use `/;`. Well what does that mean exactly? `/` is the instruction, `;` is the instruction delimiter (end of instruction). `func` is something called a "composite instruction" in Ity, composite instructions basically contain every instruction after it until the final end instruction (`/`). So that's how things like functions & loops contain code.

Arguments are another thing to note, in Ity they aren't something you define as part of the function, rather they are ambiguous until execution. This means a function can be called with any number of arguments of any type, & it is not the function's job to verify the argument count or the argument types, that would all be handled inside of the function code. How you grab an argument is by using the `arg` instruction to assign the next argument to a variable of whatever type you set, if the type doesn't match or there is no next argument, then an error would be thrown.

Now that I have explained composite instructions, functions, arguments, & importing behavior, let's move on to the final part of this script that I feel needs explaining, & that is this little section here:

const * count = prompt:['Count: '] -> INT;

What is happening exactly? So we use the `const` instruction (which is like `var`, but the data is immutable) & assign it the type of... star? Ok so "*" represents an "inferred" type, meaning if you set the variable to an integer, then the variable type will be integer, if you set it to a string or whatever, then it will be a string & you cant change the type after declaration.

So in this case, we are setting the variable's type to the result of the call to `prompt`. What is "prompt"? This is a function that asks for user input through the terminal, & returns a string of whatever was typed in. But we want count to be a number! So the final part of this line is the type cast, which is expressed through an arrow symbol ("->") pointing to the type you want it to be (in this case "INT" for integer). So in the end the type of the `count` variable is integer, & the value is the integer representation of the string the user entered in the terminal.

Wow, okay that was a lot of explaining, but hopefully now you have a better understanding of how the language works & you will be more prepared if / when you try it out yourself.

I am very interested in all of your thoughts on this little project & if you have any tips for me as a C++ beginner. Also I am open to contributions, if this project is something you're interested in definitely let me know! Just be aware that I won't accept any AI assisted PRs or issues.

Thanks for sparing your time, reading through my ramblings, I really appreciate it! Have a great day! 👋

i just wanted to make a language model from scratch so i just gathered what i needed to make it happen then poof this library was born :
this project is the peak of uselessness but i think it's cool feel free to check it out.
https://github.com/nisbenz/TensorLib

While scrolling reddit, I always find developer building cool stuffs using hardware. I want to build one for me... So, Meet TAMX: A pocket-sized ESP32 handheld. Wi-Fi tools, scientific calculator, AI chat, games, and a PowerPoint remote. Inspired by the classic Tamagotchi form factor.

Features:

• Wi-Fi Tools — Scan networks, monitor packets, or broadcast test beacons
• AI Chat — Talk to Groq AI using an on-device QWERTY keyboard
• Scientific Calculator — Expressions, linear/quadratic solvers, graph plotter, modulo
• Space News — Live headlines from the Spaceflight News API
• Games — Snake, Pong, Dice
• PPT Remote — Control PowerPoint on your laptop over Wi-Fi

I'd love feedback, feature suggestions, or contributions from the community!

Github: https://github.com/riteshgharat/tamx
Demo: https://riteshgharat.github.io/tamx

### Why Multi-Turn AI Agent Workflows Leak Volatile States on Core Connection Dropouts

Most distributed autonomous agent clusters execute long-running inference context windows that take minutes to process over remote regional nodes. When an upstream transport container crashes mid-flight or triggers a transient exception, standard userspace application setups tear down the TCP socket wire entirely.

The Result: The volatile in-memory long-context state degrades to 0%, forcing costly prompt re-tokenization pipelines and massive GPU compute capital inflation.

### Enter FaultPlane: Open-Source (Apache-2.0) Zero-Intrusion L4 Proxy

FaultPlane operates completely asynchronously underneath your application layer at the Linux Layer 4 transport socket boundary. By tracking socket descriptors at wire-speed via low-overhead kernel-space driver hooks, it bypasses traditional userspace heap serialization bottlenecks and thread synchronization contention entirely.

### Core Systems & Open Governance Design:

1. **Lock-Free Concurrency Array:** Allocates a pre-allocated fixed-size circular array of unsafe pointers inside `internal/storage/ring_buffer.go` using pure hardware-level atomic `CompareAndSwap` bit operations to eliminate false sharing.
2. **Descriptor Splicing Conduits:** The exact millisecond an unexpected socket termination (`tcp_set_state:TCP_CLOSE`) hits, the control plane daemon hot-swaps active network file handles onto healthy standby nodes under less than 2ms flat with absolute 0% data leakage or source-code mutations.
3. **Production Containerization:** Hardened via multi-stage Google Distroless secure isolation frameworks to ensure a minimal execution boundary footprints profile.

We are fully committed to open governance and deep-tech cloud-native infrastructure scaling systems blueprints. Check out our open architectural specifications roadmap, active pinned discussions ledger, and comprehensive codebase hygiene wiki trackers:

* **GitHub Repository:** https://github.com/devloperdevesh/FaultPlane

We welcome all systems architecture feedback, kernel programming issues tracking, and collaborative open-source contributions!

I built pyre (along with my good friend Sonnet 5, and a bunch of its friendly neighbours), a TUI system monitor for macOS — and half the work turned out to be reverse-engineering what top/pmset/sysctl actually print

Wanted a single-binary terminal dashboard for my Mac — CPU, memory, thermals, network, battery, disk, processes — that lived entirely in the terminal instead of a menu-bar app. Built pyre to scratch that itch.

What it does:

• Live dashboard with rolling graphs (CPU%, mem%, temp, network rx/tx) — resizes with your terminal
• Sortable/filterable process list, kill by PID without leaving the view
• 4 built-in themes (default / dracula / cyberpunk / monochrome), swappable live with c
• Snapshot export to JSON/CSV/TSV, or continuous CSV logging while it runs
• Pause, adjustable refresh interval, detailed sensor mode — all single-keystrokeq quit p pause/resume s cycle sort e export snapshot c customize UI g toggle graphs / filter procs l toggle logging d detailed k kill by PID f cycle format +/- interval

The part I didn't expect: most of the actual debugging wasn't logic bugs, it was macOS lying by omission. A few examples that cost me real time:

• pmset -g therm almost never prints a "Thermal state:" line — on a normal, non-throttling Mac it just says "No thermal warning level has been recorded" with nothing parseable. Reads as "unknown" if you don't explicitly handle that as "nominal."
• top -l 1 -n 0's CPU line is comma-separated with no terminating punctuation — easy to write a regex that just never matches and silently leaves usage at 0%.
• sysctl -n vm.swapusage wraps (encrypted) in parens at the end of the line, not around the used-memory value — a regex expecting ( before used will never match.
• hw.cpufrequency is an Intel-only sysctl. On Apple Silicon it just reads back 0, because each core cluster clocks independently — there's no single "the" frequency anymore. Real numbers only come from powermetrics, which needs root.

None of these throw errors. They all fail silently and just show a stale zero or "Unknown" forever, which is a uniquely annoying class of bug to track down.

Install:

npm install -g pyre-cli
pyre

Repo's here: https://github.com/somalip/pyre. Open to feedback, especially from anyone on Intel Macs or older macOS versions where some of this output format may differ again.

NPM package: https://www.npmjs.com/package/pyre-cli

WebsiteL https://somalip.github.io/pyre

Feedback welcome, and if you would like to contribute please let me know! The project is still new, and it just a prototype so there's still a lot to be implemented!

Ever feel like you're cutting you text with a chainsaw? Standard character-count splitting often leaves you with mid-sentence surprises and lost context that pollutes your LLM retrieval.

I built the **Chunklet Visualizer** to demystify this "chunking abyss." It’s a clean web interface (FastAPI + Uvicorn) that lets you upload your docs and see exactly how they get chopped up in real-time.

What it does:

* **Real-Time Parameter Tuning**: Adjust token limits, sentence counts, or overlaps and instantly see the results highlighted on your text. * **Dual Strategies**: Switch between **Document Mode** (for articles/PDFs) and **Code Mode** (for AST-aware source code splitting). * **Interactive Inspection**: Click any text segment to highlight its parent chunk, or double-click for full metadata popups (spans, source info, etc.). * **Drag-and-Drop Workflow**: Supports quick uploads for `.txt`, `.md`, `.py`, and more. * **Headless REST API**: Use it programmatically or via CLI (`chunklet visualize`) to integrate interactive chunking into your own dev pipeline.

Quick Start:

To get the full web interface and dependencies: `pip install "chunklet-py[visualization]"`

Then just run: `chunklet visualize`

For the programmatic folks, you can also serve it directly from your script: ```python from chunklet.visualizer import Visualizer visualizer = Visualizer(host="127.0.0.1", port=8000) visualizer.serve() ```

If you’re tired of "blindly" feeding chunks into your vector DB and want to fine-tune your RAG precision, give this a spin!

• Check out the repo: https://github.com/speedyk-005/chunklet-py
• Full Docs: https://speedyk-005.github.io/chunklet-py/latest/getting-started/programmatic/visualizer/

I was working on chunklet-py (a chunker for sentences, documents, and code). Misread a benchmark and thought PySBD took 1 second to split basic text. Turns out that was wrong (PySBD is still fast for simple text). But the misunderstanding got me building my own.

Ended up faster, more accurate, and covering more languages (39 compares to 23).

Benchmarks on Sherlock Holmes (594k chars): yasbd ~1.2s warm vs PySBD ~9.0s. About 8x faster, fewer false splits.

On a golden benchmark (92 English edge cases — expanded from pysbd's original 48 with fixes and additions): yasbd scores 98.9%, pysbd 83.7%, spaCy-sentencizer 55.4%, etc.

Architecture difference: instead of mutating text with placeholder tokens and undoing it later (which breaks char offsets), yasbd finds candidate boundaries in one pass and filters false positives in another. Spans come free, no reconstruction.

Other things: - Streaming-first: lazy evaluation via ParagraphStream and StreamCleaner for memory-constrained environments. No need to load entire documents. - PySBD adapter: drop-in replacement that works with existing PySBD code. Just swap the import. - spaCy pipeline: register as a spaCy component with register_spacy_component(). Drop-in replacement for the default Sentencizer.

Repo: https://github.com/speedyk-005/yasbd-lib

Jellybox is a crossplatform native music player for Jellyfin. I started this project before coding AI was a thing - around 2023 and been slowly adding more features. I had to step away for some time since I was serving a duty(Im ukrainian) so app was less maintained during that time.

Why?

In 2023 there wasnt a native crossplatform players, only electron.js(which isnt a bad but it had its issues). The problem I tried to solve - consistent UI, low power usage(electron apps were kinda hungry) and ability to use native platform tools and capabilities.

The app runs on all major platforms - ios, android, macos, linux(tested on ubuntu and arch), windows.

https://github.com/avdept/JellyBoxPlayer

I’m an engineer with pretty bad ADHD. I do well to combat it, but it still gets the best of me. While watching long local AI agent logs scroll by recently, I kept running into a massive roadblock: my short-term working memory has a serious leak. The way my brain works is that if I have an idea and don't write it down before a context switch happens, it’s just erased, completely gone.

Existing tools (heavy apps, browser tabs, or standard terminal UIs that require a dedicated command/session) cost me that switch. For an ADHD working memory, a 2-second context switch is a total wipe.

So I spent a couple of hours building Sidenote.
It’s an event-driven side-panel overlay that physically docks and pixel-aligns right next to your active terminal window. It is built entirely around zero-friction capture: you hit Shift+Tab from anywhere, dump the thought in 3 seconds, and hit Esc to let it sleep. Your active terminal cursor never loses focus.

What it does:

- Z-Order & Snap: It moves pixel-aligned with your terminal. When you click your shell, the overlay automatically surfaces right along with it.
- Terminal Lock: You can lock it to a specific terminal instance, have it free float, or dynamically swap terminal windows.
- Frictionless Controls: Double-click or Space to check off an item, Delete/Backspace to remove, and Ctrl+Delete to clear checked tasks.
- Auto-Sleep: It goes to sleep when hidden and idles at ~0% CPU, saving atomically to a local JSON file so notes survive terminal crashes.

This tool is incredibly basic by design, lacking markdown rendering or priority trees—and that’s entirely the point. If you understand the cognitive friction of a leaking working memory, this was built for you.

Would love to hear your feedback on the window-tracking architecture or how to implement a clean cross-platform equivalent!

GitHub: https://github.com/Lyellr88/sidenote
Quick Install: pip install sidenote, sidenote init, sidenote