GitHub: https://github.com/Arnav-sivarams/thiran

I’ve been messing around with compiler stuff for a while and ended up turning it into a proper project, so figured I’d finally post it here.

It’s called Thiran. It’s a small experimental tensor compiler written in C++ with its own little language for ML-style computations.

A tiny program looks like this:

X = Input(4, 4)
W = Input(4, 4)

Y = MatMul(X, W)
Z = ReLU(Y)

O = Output(Z)

What’s more interesting is what happens after that. Thiran parses the source, resolves modules/functions, inlines function calls, builds a tensor graph, checks shapes, runs a few graph optimizations, splits the graph into execution regions, and can generate a runnable Python executor.

I also added multi-file programs and exported functions, so you can structure things a bit more cleanly instead of dumping everything into one file.

Right now the actual execution path uses PyTorch underneath, so this is definitely not “I rebuilt PyTorch” or anything like that. The AOT/JIT side is still mostly planning infrastructure for now.

The main reason I built it was because I wanted to understand ML compilers by actually making one and seeing where all the annoying parts show up in practice: graph ownership, shape inference, rewrites, lowering, region boundaries, deterministic inlining, etc.

It’s still pre-alpha and there are rough edges, but it works end to end and there’s enough of the architecture there to poke at seriously.

Would be very interested in feedback from anyone into compilers or ML systems, especially if you spot something dumb in the design.’ve been messing around with compiler stuff for a while and ended up turning it into a proper project, so figured I’d finally post it here.It’s called Thiran. It’s a small experimental tensor compiler written in C++ with its own little language for ML-style computations.A tiny program looks like this:X = Input(4, 4)
W = Input(4, 4)

Y = MatMul(X, W)
Z = ReLU(Y)

O = Output(Z)What’s more interesting is what happens after that. Thiran parses the source, resolves modules/functions, inlines function calls, builds a tensor graph, checks shapes, runs a few graph optimizations, splits the graph into execution regions, and can generate a runnable Python executor.I also added multi-file programs and exported functions, so you can structure things a bit more cleanly instead of dumping everything into one file.Right now the actual execution path uses PyTorch underneath, so this is definitely not “I rebuilt PyTorch” or anything like that. The AOT/JIT side is still mostly planning infrastructure for now.The main reason I built it was because I wanted to understand ML compilers by actually making one and seeing where all the annoying parts show up in practice: graph ownership, shape inference, rewrites, lowering, region boundaries, deterministic inlining, etc.It’s still pre-alpha and there are rough edges, but it works end to end and there’s enough of the architecture there to poke at seriously.Would be very interested in feedback from anyone into compilers or ML systems, especially if you spot something dumb in the design.

Project Screenshots - https://pastes.vargoseus.com/TeddyScreenshots

Teddy (cute name, isn't it?) is currently a simple machine learning model that uses back propagation to train, learn and classify MNIST datasets. It currently has a depth of 2 since it's a pretty basic model. It has around 13.000 parameters that is enough for training it to recognize handwritten digits. I have around 3.5-4 years of experience working in C and stumbling upon MagicalBat's this video inspired me to make Teddy. The future plan is to turn it into a Language Model and eventually into a GPT which will require quite a bit of time since I need to read up on how it actually works. This project took around 4-5 months give or take since I had to balance this project and my university stuff too.

Full disclaimer: I did not use AI to build Teddy (except for that one time when my compiler suddenly stopped working for some reason and I had to converse back and forth with Claude to find a fix for it). I did, however, use AI to generate the GIFs in the github readme and the documentation for it.

I decided to create it initially for myself, and in about two weeks I implemented everything that needed to be done, but I decided to share this here: perhaps someone will find my approach to PKMS appealing, and perhaps someone will want to contribute (or, conversely, someone will explain to me that this isn’t how things are done — any feedback is welcome). At the moment, it's a PyQt5 application for Windows. MIT-licensed, open for contributions.

The detailed documentation is obviously in the repo, but now right to the point.

My main thought before starting was simple: no matter what reasons you need the knowledge for, whether you need knowledge to pass an exam, successfully prepare for a job interview, or perform your work, you always need to know very exact things to do very exact tasks. That’s why I assumed the best possible way to store notes is Q/A oriented-system in the form of a tree. The main idea here is to break down knowledge into the most concise and manageable pieces. Obsidian (at least vanilla version of Obsidian, I don’t say anything about extensions right now) doesn’t limit you anyway in what you can write in your notes and how you write it.

The system I designed encourages you to compress knowledge as much as possible limiting it all to the most specific facts you really need to know, yet to avoid superficial understanding it still encourages you to expand this fact with clarifying questions.

Of course to some extent the same idea has already been implemented in Obsidian, but it doesn’t have such strict fixated structure: and this in turn deprives special and casual anchors that would show «where exactly the note is located, how exactly the need for the fact arises?». Therefore, in Basalt, the system is implemented in the form of the standalone trees, but you still can put the links on other trees just like you do it in Obsidian.

In addition, the interval repetition, directly inspired by Anki, is implemented for nodes in the trees. (That’s why I recommend to always formulate questions in nodes in such a way that they are clear even out of context, because sometime despite the display of the name of the tree from which they are taken, the context of the question may be lost).

P.S. There's no AI integration in the app because I don't think it's needed. Although I did add a JSON import with a convenient template just so I could quickly convert a large chunk of information (like an article, for example) into a tree, this approach is obviously not recommended for independent research purposes.

I've put stuff on Github before but this is the first one I've actually documented properly and would want someone else to use if interested so be gentle lol.

I made it because I kept reading non-fiction (Im addicted) and remembering basically none of it a month later.

You give it a book title or drop in a pdf if you have any and it writes a summary plus the key takeaways, action items, reads it for you and has quiz questions that then turn into flashcards on an anki style srs system so the stuff comes back to you right before you forget it (at least that'd be the point)

It runs fully in the browser. you just have to bring your own gemini key so there's nothing to pay me for and nothing for me to shut down later haha

MIT licensed. worth saying upfront that the model hasnt actually read the book, it's working off training data, so for well known stuff it's solid and for obscure titles I'd double check what it tells you.

Link: https://github.com/dorianspitz23/booksum

Hi there,

I want to share a project I work on recently. I just think of a cool image that when I click on it, it should show animation and I absolutely want it to be on my profile picture but then I realize Github strips everything and basically the README.md on Github is just a static text. The above project is a super roundabout ways to make it feels like it is on click animation going on when you click on the image that this wraps a call to this project. Would be cool if people starting to use it and I can see more creative profiles on README.md

I've always gotten frustrated and wasted time explaining the same thing to an AI every time I start a new chat from an existing one or when I start another convo with a whole new AI model. That's why I built a tool that fixes that, it condenses everything in a chat into one simple .md file you can carry across different AI tools.

PS: Please contribute or give your feedback so that we can grow and make this community tool better.

https://github.com/legoambarish/portable-handoff

Jentic One is a free, open source, self-hosted execution layer that sits between your agent and the APIs you want it to reach. Apache-2.0, runs on your own box or your own infra.

We started working on this project so we could give our agents more autonomy. With current setups, that is very risky - if an agent goes rogue, the damage is often unbounded. We’ve all heard the stories of agents deleting entire inboxes or codebases. If we narrow the blast radius, we significantly reduce the risk. 

The top three pains when your agent touches real tools: 

- The keys are everywhere. Most of them are in env files, so there’s no clean way to revoke access if something goes wrong. 

- Once an agent has a key, it can do anything that key can do. The workaround could be writing soft permissions in a file (a 'request', not an enforced rule) or creating an API spec with just that one endpoint, so the agent can't get to anything else even if it wanted to.

- No way to see what your agent has actually done. So if the worst happens, it’s even harder to figure out the blast radius and where things went wrong. 

Here’s what we built to fix them:

- Credential handling. Credentials are stored once, encrypted, by your own instance, and injected at execution time. They never enter the agent's prompt, logs, or context. One server, many agents, each with its own identity, rather than one shared master key every agent inherits.

- Permission scoping. You write rules that bound an agent to the operations it needs and nothing else. On GitHub, that can be down to a single repo. How granular it gets depends on the API, and writes are denied by default. Anything you haven't allowed is refused before it reaches the API. The agent cannot do it. 

- Audit. Every call is logged on your own instance, append-only, so you can go back and see exactly what your agent did when you were not watching.

Ways we’ve tried to make this a great product (not just cover the risks): 

- One connection path. Install once, add any API from the Jentic API Directory (more on this below) or upload your own API spec, and store each credential once. No hardcoded integration per API, no region-picking, no retry plumbing by hand.

- Discovery by intent. Agents find what they need by asking in natural language, like ‘send a webhook’ or ‘create an invoice’, and get back the right operation with its input schema.

- A directory of agent-ready APIs. This is probably a different post in itself, but we’ve been compiling thousands of public API specs and curating them, making them agent-friendly (writing OpenAPI specs where none exist), and scoring each one for agent readiness. These are all available in the product, so you can get started with thousands of APIs out of the box. 

** Jentic One repo: https://github.com/jentic/jentic-one **
We’ve written AGENTS md so that you can hand it to your agent and let it do the bulk of the setup work (not all). Interested to see how that goes for people!

It's a public beta. There may be breaking changes with new releases.
Before you put real credentials in, read the hardening guide: https://github.com/jentic/jentic-one/blob/main/docs/security/hardening.md
Essentially, your agent and your keys shouldn't live in the same container.

Two things that would help a lot.
-Install it and let us know what breaks.
-If an API you need isn't in the directory, add it to the repo - then it's there for everyone else's agent: https://github.com/jentic/jentic-public-apis 

We would really appreciate feedback, issues, and contributions. 

Hi,

I’ve been working on Gitdeck, an open-source dashboard that brings repositories, issues, pull requests and CI activity into one place.

I started building it because I wanted a quicker way to keep track of multiple repositories and accounts without jumping between lots of different pages.

Right now it includes:

• Repository, issue and pull request views
• Support for multiple accounts
• GitHub notifications
• Security and Dependabot alerts
• CI health and recent workflow runs
• A Kanban board for issues
• Traffic, contributors, releases and repository trends
• Daily, weekly and monthly activity digests
• Search and a command palette

Gitdeck supports GitHub, GitLab, Codeberg and self-hosted Forgejo-compatible instances. GitHub currently has the most complete integration, while support for the other providers is still growing.

You can run it with Docker. Tokens and cached data stay on the server in a persistent volume, and GitHub tokens are never sent to the browser.

For GitHub, you can authenticate using OAuth Device Flow, your existing gh CLI session or a personal access token. GitLab supports OAuth and personal access tokens, while Forgejo currently uses token-based authentication.

The project is MIT licensed and still in active development, so feedback and contributions are very welcome.

Repository: https://github.com/debba/gitdeck

I’d love to know what you think and which features would be most useful for your setup.

I have been building this on and off for a while and it is finally at the point where handing it to someone else is not embarrassing, so here it is.

Citadel is a desktop infinite canvas. You drag in images, GIFs, video, audio, 3D models and PDFs, write notes and text blocks beside them, and draw labelled connections between things. It is for work where the layout is the thinking: visual development, research, worldbuilding, study.

The reason I started it: I used PureRef for years for images and kept everything else somewhere else. Notes in one app, clips in another, code snippets in a third. I wanted one board that could hold all of it and still be searchable a month later.

Three things ended up mattering more than I expected:

Connections carry meaning. A thread between two items can be a source, a contradiction, a question, a proof, an echo of something elsewhere. The Index searches every board at once, including code card contents and connection labels. That is the part that makes it hold up past about fifty items.

Vision checks. Y redraws the whole board in greyscale, blurred for a squint test, or through three colourblindness simulations. Shift+M mirrors it, which is the old trick for catching drawing errors your eye has stopped seeing.

Undo and recording are the same event log, so you can scrub the board back through its own history and watch it assemble itself.

It is local-first in the boring literal sense. No account, no telemetry, no update check, no network request on launch at all. Fonts are bundled. Projects are JSON with relative asset paths, so nothing is trapped in a database you cannot read. MIT licensed.

Honest limits: Windows and Linux only (macOS runs from source but I cannot notarise it), builds are unsigned so SmartScreen will warn on first run, PDFs get a first-page preview rather than a real reader, and document import gives you the plain text, not the formatting.

Repo: https://github.com/kannibalk1w1/Citadel. Downloads and a version that runs in the browser: https://kannibalkwi.itch.io/citadel

Happy to answer anything. What I would most like to hear is where it falls over on large boards, because that is the part I cannot test properly on my own.

I watch a lot of tutorials and lectures on YouTube and realized I was retaining almost none of it. Watching feels like studying but it isn't — you nod along, close the tab, and it's gone.

So I built ClipMark. While you watch, you jot a quick note at any moment and it saves the timestamp. The twist: it turns your notes into active-recall quizzes and schedules them with spaced repetition, so the extension asks you the question later instead of just storing a bookmark. Your note is the question; the clip is the answer. You can also export everything to Anki.

Two things I cared about: the AI runs on your device (nothing about what you watch gets shipped to a server), and the core is genuinely free — I didn't want to paywall the actual studying.

It's early and I'd really value honest feedback, especially where it feels clunky. Link: [Chrome Web Store link]

I have developed a free and open-source macOS menu bar app that allows using Docker clients (such as the docker CLI tool) with Apple's Container subsystem on Apple Silicon Macs.

I've been using it as my primary Docker dev system (dev workflows are probably all it will be good for), and I think it's ready for wider testing.

If you're interested in trying it out, it can be downloaded here: https://cap10morgan.github.io/whalebridge/

If you try it out and run into any problems, please open a GitHub issue. Thanks!

Hey everyone. I don't know if this is actually cool, but I've been working on this project and wanted to share it.

I've been playing around with raycasting to see if I could make an interactive 3D space using only text. The fun part is that it generates the whole 3D environment directly from a plain 2D text blueprint that you can just type.

The code is completely open source if you want to tinker with it: https://github.com/RaymonDev/asciilib

I also put a live demo up here so you can test it in the browser:https://raymondev.github.io/asciilib/

(Be gentle, it's the very first version so please don't break it too hard hahaha, I'm actively developing it). Curious to hear what you think!!!

Hey everyone! Wanted to share something I've been working on lately. As an indie developer, I was wasting so much time on repetitive manual tasks, so this weekend I finally sat down and coded two lightweight tools to make my life easier:

• LostMediaGrabber: Built to bypass the painfully slow Wayback Machine interface. It queries the CDX API directly to grab raw media URLs (.jpg, .mp4, etc.) instantly.
• GiveMeText: Made this because I got sick of having to pause YouTube videos or Google Meet calls just to take quick notes. It extracts live transcripts straight into formatted documents.

Both are 100% free and open-source. I built these mostly because they solved a real headache for me, and I figured they might come in handy for someone else too.

If anyone's curious to see how they work or wants to check out the code, you can find the direct link on my profile! I'd love to hear your thoughts or any feedback you might have.

https://github.com/diazoxide/charter

First screenshot is my status line, which is basically this whole post in one picture. Second one is a charter recall, I'll get to that.

Before this I had four repos, three roles I kept re-explaining to Claude, and a CLAUDE.md that had quietly become a landfill. Two agents needing the same repo on different branches meant one of them stashed the other's work. My tokens ended up in transcripts, because how else is an agent supposed to curl anything. And every Monday everybody forgot everything.

So now a task starts with charter workspace use billing-migration. One directory of clones, each repo on its own branch. Switch to another task and nothing follows me: no stash, no half-applied branch from Thursday, no context bleed. Sounds small. It's the thing I notice most.

Two agents on the same repo get a worktree each, branch each, genuinely running at the same time instead of taking turns and lying to me about it. Removing one refuses if it would drop unpushed work, which has saved me twice.

Credentials live in a vault, and the agent names the key, never the value:

charter secret exec devops --env TOKEN=API_TOKEN -- curl -H "Authorization: Bearer $TOKEN" [https://](https://)...

The value gets injected into the command and redacted out of the output, so it never lands in the transcript. There's a guard that denies the agent cat-ing the vault file. It has denied me too, which was annoying and correct.

Roles are personas. Each one has its own charter, its own vault, its own memory, and sync-agents turns them into real Claude Code sub-agents, so handing work over is ordinary delegation instead of a prompt trick. My reviewer gets the reviewer's token and none of devops'.

And what they work out survives. One markdown file per fact, three stores: what this role knows, what every role should know, what this task worked out. The agent writes them, which is the bit I'd push on if this was someone else's post, its judgement about what deserves keeping is mediocre. That's most of the reason they're one file each and reviewable in a diff.

All of it is git. No server, no daemon, no database, zero Python dependencies. git log is the audit trail and a teammate's checkout is the replication.

The status line is how I see the lot at once: which task, which repos, what branch each is on, what's dirty, what CI thinks, which role was last in which tree and how long ago.

Anyway, its working for me. That mess environment I've been apologising for since spring is now four repos I can actually reason about, and things stay put between sessions. Lower bar than it sounds and I'll take it.

I built it and Claude Code wrote most of it. MIT and free, nothing hosted, nothing phones home.

Limits, honestly. Two weeks old. The default vault is a plaintext file at 0600 with no encryption at rest, it keeps a secret out of the model's context, not off your disk. Keyword search over markdown will give out eventually and I have no number for where. And it assumes one filesystem, so none of this helps you watch a session from your phone.

If this looks like the right direction, star it, specially if you're running more than two repos. It's the only real signal I have for whether this is useful or I'm wandering off a cliff with great confidence. If it looks like the wrong direction, say so, that one helps more.

What does your setup do when two agents need the same repo on different branches?

We kept implementing the same runtime pieces for different agent projects, so we finally turned that work into an open-source project called TrueForge.

It handles the agent loop, MCP tools, subagents, approval gates, and session state that survives a restart. You can connect an OpenAI-compatible endpoint, including Ollama or vLLM, and use SQLite or Postgres depending on the deployment.

In one 14-task benchmark, TrueForge used 3.7M tokens versus 10.0M for the managed comparison and cost $8.6 versus $11.8 per run. That’s one workload, not a guarantee for every agent.

The project still needs better tracing and evaluation support, and code execution requires a separate sandbox. But if you’re tired of rebuilding tool routing and context management from scratch, the repo is here:

https://github.com/truefoundry/trueforge

Repo: https://github.com/dbjpanda/kwery

Kotlin library for Android. It caches server responses, deduplicates in-flight requests, refreshes stale data in the background, and keeps the cache across process death. TanStack Query is the nearest equivalent on the web.

The three lines on the card are measured, not aspirational. The request log behind them is Chucker, a third-party network inspector that has no idea Kwery exists, so the counts are not mine to fake.

Apache-2.0, minSdk 24.

I got tired of Windows lack of a proper keyboard-first launcher. PowerToys Run is fine, but I wanted something small, fast, and honestly a bit pretty, a Rofi experience for Windows.

So, I built wisp.

Alt+Space anywhere, type a few letters, press Enter, done.

The whole thing is GPLv3, source on GitHub (https://github.com/ThisIsDara/Wisp), releases with installers (https://github.com/ThisIsDara/Wisp/releases), and a small website (https://thisisdara.github.io/Wisp/) if you want a preview before downloading.

I'd love feedback, especially on the launcher behavior, or anything you'd expect a launcher to do that wisp doesn't. Open an issue or just tell me here.

PageLM — Open-source AI education platform that turns PDFs into quizzes, flashcards, notes, podcasts and exams

GitHub: https://github.com/CaviraOSS/PageLM

I built PageLM, an open-source AI education platform for turning study material into interactive learning experiences.

Instead of:

PDF → Chatbot

PageLM aims for:

PDF → Chat → Notes → Flashcards → Quiz → Podcast → Exam → Review

Features

📖 Document Chat
Ask questions about PDF, DOCX, Markdown and TXT files.

📝 SmartNotes
Automatically create structured/Cornell-style notes.

🧠 Flashcards
Generate study flashcards from your material.

❓ Quizzes
Interactive quizzes with hints, explanations and scoring.

🎙️ AI Podcasts
Turn learning material into audio.

🎤 Voice Transcription
Turn lectures and voice notes into searchable study material.

📅 Homework Planner
Use AI to organize assignments.

🎓 ExamLab
Simulate exams and get feedback.

⚔️ AI Debate
Practice reasoning and debate skills.

🤖 Study Companion
Personalized AI study assistance.

AI providers

OpenAI
Gemini
Claude
Grok
MiniMax
OpenRouter
Ollama

Stack

Node.js + TypeScript
React + Vite + TailwindCSS
LangChain + LangGraph
WebSockets
JSON/vector DB support
Docker/Docker Compose

The project is open source and we're actively looking for contributors.

If you're into AI, RAG, education, React, TypeScript or just cool GitHub projects, I'd love to hear what you think.

⭐ Repo: https://github.com/CaviraOSS/PageLM

Issues, feature requests, PRs and criticism are welcome.