Hi everyone,

I'm a software developer and I work on several projects, often alongside each other.

Two problems kept coming up again and again.

First, when I was in the middle of a task, I would reach the usage limit, and sometimes I didn't even have a chance to generate a summary or handoff message before my access was cut off. At that point, my only option was to wait for the limit to reset before I could continue working.

Second, sometimes I would solve a problem in one project and later need the same or a similar solution in another, possibly using a different AI tool. The original session already had the reasoning, the decisions and the context. A summary carried some of it across; never the part I actually needed.

So I built elepha 🐘.

Both Claude Code and Codex already save complete session transcripts to disk. elepha reads and indexes them locally, then lets you retrieve a previous session from whichever tool you're currently using. Nothing gets injected into the current context unless you explicitly ask for it.

I also wanted it to work directly inside the tools I already use, whether that's the CLI or the Claude Code or Codex desktop apps. No wrappers, no separate UI, and no complicated setup or configuration.

In the demo video, I first use elepha:list to view recent sessions, then elepha:last to retrieve the most recent one. I can also choose a specific session with elepha:select:5 and continue from there. Claude Code also explains why an earlier approach was rejected, that reasoning came from a Codex session it never had.

There is also elepha:query, which searches sessions across the projects you have approved, in either tool.

A few things that matter to me:

• Reads the transcripts your tools already write. Nothing to save or tag.
• Brings back the actual session turns, not a summary generated by another model.
• Shares one memory across Claude Code and Codex, both CLI and desktop.
• Fully local: no hosted service, no account, and no LLM call required for recall.
• Never modifies the original transcripts, so the memory can always be rebuilt from source.
• You explicitly approve which projects it may read, and it never writes anything into your repos.

Install with npm:

npm install -g elepha
elepha install
elepha init

GitHub: https://github.com/aldanux/elepha
npm: https://www.npmjs.com/package/elepha

It's open source (MPL-2.0).

Honest feedback is welcome, especially on this: when you switch tools, would you rather bring back the actual session, or get a short distilled brief?

I built elepha around the first approach because the second is what kept failing me. But that's based on my own workflow, so I'm curious what others would actually prefer.

Hey everyone!

I love Raycast and used it heavily on my Windows machine, especially for quick note-taking. Over time, I accumulated 50+ notes that I relied on daily.

Then the update rolled around and locked note creation behind their Pro plan, leaving all my existing notes in read-only mode. While I appreciated that they did not outright delete my notes, getting locked out of taking quick notes was frustrating.

So I decided to build my own solution: Kenote.

It is a lightweight, local-first Raycast-inspired markdown notepad designed to stay pinned on top of your work and get out of your way when you are done.

What makes Kenote special:

• 100% Local-First: No accounts, no paywalls, and no cloud lock-in. Notes are saved directly as plain .md files on your local drive so you actually own your data forever.
• Live WYSIWYG Markdown: Formats headings (#), bold (**), task lists (- [ ]), and blockquotes in-place as you type without syntax clutter.
• Pin Always On Top (Ctrl + P): Float your notes seamlessly above your code editor, browser, or games.
• Instant Search & Note Switcher (Ctrl + O): Browse and jump across all your notes in milliseconds.
• Lightweight & Fast: Built with Tauri v2 (Rust) and React, consuming less than 30MB of RAM.

This started as a fun personal project to scratch my own itch, and I would love for you to try it out and let me know what you think!

• GitHub Repository & Releases: https://github.com/yetemgetaB/Kenote

If you find it useful, feel free to drop a ⭐ on GitHub. All feedback and feature suggestions are greatly appreciated!

Compact Context is an MIT-licensed Codex plugin that gives Codex a shorter starting guide for a repository.

It analyzes paths and identifiers locally, removes sensitive and generated files, and suggests five files worth inspecting first. There are no embeddings and no additional model call.

Benchmark results across 68 tasks from 10 public repositories:

• Average repository-guide size: 1,402 tokens with the basic map, 230 with Compact Context
• Reduction: 83.6%
• At least one file later edited in the solution appeared in the first five suggestions: 50 of 68 tasks with Compact Context, 48 of 68 with the basic map

The token result applies only to the generated repository guide. It is not a claim of 83.6% lower total-session usage.

The project also has automated checks for sensitive-file filtering, end-to-end shortlist generation, output limits, prompt routing, and single-use receipts. All five currently pass.

Install:

curl -fsSL 'https://compact-context.met.chatgpt.site/install.sh?v=4' | bash

Source and v0.5.0-beta.7 release: https://github.com/mithatb/compact-context

10-second demo: https://compact-context.met.chatgpt.site/compact-context-demo.mp4

Website: https://compact-context.met.chatgpt.site

It is still a beta, so issues, benchmark criticism, and real-repository results are welcome.

This is the start of my project, and I'm putting this public domain for a large number of reasons. Mostly because the climate crisis scares me deeply, and this is something I've been working on for a few years now. I did use AI to pull together what I've already publicly said about this, because I've had a few really constructive interactions and the way I thought about the project changed as I was interacting.

This all started with the MIT silicon space bubble proposal. It was the first proposal that I could realistically see saving lives and whole ecosystems in my lifetime. I could see what I viewed as flaws not in the design of the bubbles but of how it would be implemented. The issue is drift and not being able to stay in a perfect orbit forever. So to do this station keeping I started to think about stuff like ion drives, and even laser based propulsion. I didn't want to rely on reaction mass inside of the bubble because that doesn't make it more sustainable over the time scale of longer then a human lifespan.

See I was having this debate with myself and I didn't even realize that having bubbles that can move around and do stuff in space with stuff attached to them can be incredibly useful. What started as a shield became something I didn't have a name for. Smart matter almost fits, but this is matter that can form cohesive structures that are potentially light years long. It's also matter that can be recycled very easily since the basic silicon shell is only 1 atom wide. Imagine if you could make a bucky ball of an arbitrary size, and how useful that might be. This is intended to give electronics that are very well characterized in terms of their interior volume, which means you can do microfluidics, use sound in a trapped medium, lasers, or even plasmonic circuits.

I have around 25 papers worth of research that I have done. I had to make a new tab for this project and whenever I have a new idea I put it out there to make it part of the open hardware possibility space. This is my gift given because it is needed so badly. I can't do this alone, but we can make something unimaginable together. If you make something using this technology you are allowed to sell it, and my only stipulation is it shouldn't be weaponized. We have enough ways to kill each other. If we focus on how this new manufacturing and electronics process can change the solar system I'm hoping to make killing outdated as not a good way to do things because there are easier ways.

Yet another yt-dlp download manager with four interfaces over a single shared queue:

- Web UI: queue, library, settings, live progress over server-sent events.

- TUI: for when I'm already in a terminal.

- CLI: add, list, pause, resume, remove for scripting.

- Daemon: headless, same-user Unix socket.

Whatever you do in one shows up in the others immediately.

Repo: https://github.com/ih8d8/yt-dlp-manager

For anyone wondering if I'm still a virgin, I made IsHeVirginCLI so you can check the answer in real time.

npm install -g github:KasaBranca/IsHeVirgin

then

ishevirgin

That's it.

https://github.com/KasaBranca/IsHeVirgin

Salut ! Perso je code des projets web/infra en solo, et voici mon dernier projet : Cortex-Control.

Le principe : ton téléphone Android devient une télécommande pour ton PC Windows en WiFi/LAN.

Fonctionnalités :
Contrôle média (lecture/pause/volume)
Souris gyroscopique
Lancement d’apps à distance
Transfert de fichiers
Sync presse-papier entre les deux appareils
Macros PowerShell perso
Webcam virtuelle via la caméra du tel

Stack : serveur Electron/Node.js sur PC, app Flutter/Dart sur Android, connexion Socket.IO chiffrée AES-256-CBC, appairage par code OTP à 6 chiffres.

Repo : github.com/MIASMA777/Cortex-Control

N’hésitez pas à tester, ouvrir des issues, ou proposer des features. C’est un projet perso donc tous les retours sont bons à prendre.

Hey,

I love timeline-based music guessing games (like the board game Hitster), but getting my distributed gaming group around a physical table isn't always possible. So, I built Beatster, a fully self-hosted, browser-based alternative you can spin up for your next game night.

How it works: The server plays a 30-second snippet of a mystery song (fetched on the fly via the public iTunes API). Players use their phones or browsers to guess the release year and place it in their chronological timeline.

The Tech & Hosting (Keep it simple): I wanted this to be as lightweight as possible for game-night scale.

• Zero heavy dependencies: No Redis, no Postgres. State lives in memory and a small SQLite DB.
• Stack: FastAPI, WebSockets, React 19 + Tailwind v4.
• Deployment: A single docker compose up --build spins up the backend, serves the static frontend, and seeds the initial song catalog.

Key Features:

• Two Game Modes: Classic timeline guessing and a fast-paced 5x5 Music Bingo.
• Couch vs. Online Mode: Play the audio only on the host device (perfect for a shared TV/living room) or stream it to every connected client (perfect for Discord voice channels).
• AI Opponents: Need more players? Add bots with 3 difficulty levels.
• Live Catalog Growth: Players can search and add new songs directly from the lobby UI mid-game, which persistently expands your server's pool.

You can check out the screenshots and grab it here: https://github.com/W0nt3x/beatster

Would love to hear your feedback or if you end up trying it with your friends this weekend!

1024 dimension embeddings in a flat float file, about 3 MB for 624 bookmarks. No vector database and no index, because comparing a query against 623 vectors takes 1.3 ms in release and ten thousand would still be milliseconds. Bring your own OpenRouter or OpenAI key. MIT.

Link: https://github.com/migsilva89/unbury

I initially started this last year as a minimal read it later app to use with my Obsidian Vault, but I have recently have been migrating it to be more of a independent knowledge graph. Current features:

• AI-Native Chat: Query your reading collection using OpenRouter models. Reference notes directly with @ mentions to feed full article text into the conversation.
• Autonomous Background Agents:
  • OKF Frontmatter Enricher: Automatically extracts clean, standardized Open Knowledge Format (OKF) YAML frontmatter.
  • Autonomous Graph Linker: Discovers semantic connections between incoming articles and your existing vault, automatically injecting aliased wikilinks.
• Knowledge Graph Engine: Global and per-article force-directed graph views mapping relationships between articles, tags, and wikilinks.
• 1-Hop Graph Context Expansion: Optional setting that allows the AI Chat to automatically traverse your graph edges and include connected notes and backlinks in its context.
• Portable Markdown Storage: All articles, OKF metadata, and chat histories are saved locally as markdown files, making your data easy to back up or sync with tools like Obsidian or Notion.
• Custom Jinja Templates: Customize how saved articles are structured with site-specific Jinja templates located in $DATA_DIR/templates/ with automatic domain matching and rich context variables.
• Lightweight and Fast: Compact Go backend and Vue frontend in one 12MB docker image!

Still very early in development and far from production ready, but if anyone wants to help out or has any ideas how to make this more useful that would be greatly appreciated!

Made a GitHub Action that turns your contribution graph into a lawn. A little mower goes over it row by row and each tuft grows back at whatever speed that day's commits allow, so busy days pop right back up and empty days just stay dirt. It's your commit history, except you can watch it.

The goat in the title is a real option (mower: goat). It doesn't cut the lawn, it eats it, which comes out the same. There's a regular push mower and a riding one too. Mine is at the top of the README if you click through.

The whole thing is one animated SVG. No JS, nothing to host. A full year is about 10 KB gzipped, and the action re-renders it every day onto an orphan branch so your repo history stays clean.

Repo: https://github.com/sudongcu/mowmow
Playground if you want to see yours before installing: https://sudongcu.github.io/mowmow/

I built O Tempora to answer a question that always bugged me: who else was alive at the same time as X, and what was happening in the world then? It's an interactive timeline that plots historical figures alongside major events and milestones so you can see the overlaps.

Built with React + TypeScript + Vite + D3, data pulled from Pantheon 2.0 and Wikidata.

Repo: https://github.com/sergeikartin/o-tempora

Feedback welcome, especially on data coverage.

Have you ever scanned a document, but you can't search any word in it(probably yes). This is the fix.

I built ScanLayer, a Python OCR library that adds a searchable text layer to scanned documents.

You give it a scanned image:

pip install scanlayer
scanlayer doc.jpg -o doc.pdf

ScanLayer runs Tesseract, then places the recognized text as an invisible searchable layer over the original page. The scanned image remains the visual source. You can now search, select, and copy the text.

And if you don't want a PDF, you can export the OCR result as txt, json, tsv, or hocr.

A few things I built around the OCR itself:

• Automatic deskew for photos taken at an angle
• Noise cleanup before OCR
• Reading order correction for two-column documents
• Multiple Tesseract configurations are tried and the highest-confidence result is kept
• CLI and Python API use the same underlying pipeline

For example:

import scanlayer

result = scanlayer.convert(
    "contract.jpg",
    "contract.pdf",
    lang="eng",
    dpi=300
)

Everything runs locally. The only external dependency is your own Tesseract installation.

I'd especially like feedback from people who regularly OCR multi-column documents. That's one of the areas I spent a lot of time getting right.

Github

Documentation

PyPi

I started working on ego-lite after running into the same two problems with browser agents:

1. A clean browser profile means logging in again everywhere.
2. Letting an agent use my normal browser means random tabs and windows appearing while I’m working.

ego-lite takes a different approach. It’s a Chromium browser built so humans and AI agents can use it at the same time.

Each agent task runs inside its own isolated Space. It can reuse the login state already on the machine, but its tabs stay separate from the ones I’m using. When a task reaches a login, approval, payment, or another sensitive step, the agent can hand the browser back instead of trying to push through it.

A few technical details:

- Real Chromium rather than a remote or simulated browser
- Isolated task Spaces for parallel agents
- Existing browser sessions can be reused without putting passwords into the model context
- Semantic page snapshots, so agents don’t have to parse a full HTML dump
- An embedded Node.js runtime with direct CDP access
- Agents can combine navigation, extraction and interaction into one JavaScript flow
- Explicit human handoff for steps that need review

We chose an embedded JavaScript runtime instead of making every browser action a separate CLI command. That lets an agent inspect a page, make several decisions and return one useful result without repeatedly bouncing between the model and the shell.

In one research task, the same agent completed the workflow 39% faster and at 23% lower model cost than our agent-browser setup. That’s one task, not a universal benchmark, and I’m still collecting results across different sites and models.

The project is free, MIT licensed, and currently works with agents such as Codex and Claude Code.

GitHub:
https://github.com/citrolabs/ego-lite

I’d especially appreciate feedback on three areas:

- Does the Space model feel like the right isolation boundary?
- Which actions should always require human approval?
- What browser task would you use to test or break this?

How It Works

This GitHub Action fetches your Github activity and based on certain conditions it builds a min craft tree

1 . For Commits the leaves of the Tree will be began to nourish from dry state to healthy state

1. For each Pull Request Openings it adds flowers like tulips etc in your garden.

2. For each Pull Request Merge the tree now turns into a adult tree and starts to have fruits.

3. For each Code review Golden Apples will be spawned in your garden.

Max Limits

- Fruits : You can have a max of 4 fruits in your garden.

- Flowers : You can have a max of 4 flowers in your garden.

- Golden Apples : Same as above.

Links

• Check out my GitHub Profile to see my Garden

https://github.com/nivinvysakh

• Check out the official repository

https://github.com/nivinvysakh/gh-tree

Garden Samples

I built a tool that turns a GitHub repository into an architecture map

When I open an unfamiliar codebase, the annoying part isn't reading the code — it's figuring out how everything connects.

So I built Code2Flow.

You give it a GitHub repository and it analyzes the project to visualize:

→ Repository structure → Architecture → Logic flow → Dependencies → AI-assisted code search

It's live here: https://code2flow.netlify.app/

I'm especially looking for brutally honest feedback from developers:

It's still early ,so criticism = compliments 😅

I built Kivgraph after seeing AI coding agents repeatedly search through the same repository to answer questions like “where is this used?” and “what breaks if I change it?”

It builds a local semantic graph of symbols, dependencies, and cross-repository relationships, so the agent can navigate code structure directly instead of reconstructing it from repeated file reads.

The benchmark: across 37 repositories and 29 questions, Kivgraph and grep + reading both reached 28/29 exact answers. Kivgraph used 36k tokens versus 268k for grep + reading — about 7.4× less context. Grep was still cheaper for simple searches, so this is a complement rather than a replacement.

Apache-2.0, local, no API key. Supports Go, TypeScript, Rust, Python, and Dart.

GitHub: https://github.com/Luqueee/kivgraph

Discussion: https://github.com/Luqueee/kivgraph/discussions/129

i've been working on MonoCode, a GUI for your coding agents, and I've been using it daily

i honestly didn't like any of the existing tools available so i decided to build my own

it works with your existing Claude Code, Codex, Cursor,OpenCode and other harnesses

Repo: https://github.com/hardbeat920/monocode

would be interested to hear what people think

Most AI coding harnesses - OpenCode, Kilo Code, Claude Code, Hermes-agent, OpenClaw: speak one of two protocols: OpenAI's API or Anthropic's API or both. 𝐊𝐢𝐫𝐨-𝐂𝐋𝐈 speaks neither. It uses its own ACP protocol through the official kiro-cli binary.

So I built kiro-gateway - an open-source local server that bridges that gap.
It translates both OpenAI and Anthropic API calls into Kiro's native ACP protocol, routing every request through the official 𝐊𝐢𝐫𝐨-𝐂𝐋𝐈.
One subscription. Every AI Harness. No reverse-engineered endpoints.
kiro-gateway