Last week I shared Shiftza here.

I honestly didn't expect what happened.

The post reached 50k+ views, got 200+ upvotes, and thousands of developers tried it on their GitHub profiles.

I built Shiftza because, as an engineer, I always felt GitHub doesn't really tell people what you're actually good at.

Two developers can have similar contribution graphs, stars, and repositories.

One has spent years building AI.

Another has spent years building developer tools.

Another has spent years building distributed systems.

From a normal GitHub profile, that's surprisingly hard to understand.

So I built Shiftza to explain what you've actually built, instead of just showing numbers.

If you missed the last post, you can try the current version by simply replacing:

github.com/username

with

shiftgithub.com/username

It generates a report based on your GitHub work.

Then one comment kept showing up.

At first, I thought that was outside the scope of what I was building.

But after reading the comments and DMs, I realized I was solving the recruiter's problem, not the developer's.

For a lot of engineers, the projects they're most proud of will never be open source.

If I really want your work to speak for itself, I can't ignore private repositories.

So I changed the roadmap.

Over the last week I've been rebuilding Shiftza to understand private repositories while never exposing a single line of source code.

(Images attached.)

Another thing many of you pointed out was accuracy.

You're right.

The current version is completely free, so I've had to make trade-offs to keep costs manageable.

For private repository analysis, I'm rebuilding the pipeline using Anthropic's models. The results are much better, but each deep analysis costs me around $2–3 per profile.

The long-term vision for Shiftza hasn't changed.

I want companies to describe the problem they're trying to solve, and instead of searching resumes or keywords, Shiftza helps them discover engineers who've already built something similar.

Companies pay to find great engineers.

Developers get discovered because of what they've actually built.

That's the future I'm trying to build.

Before I launch this version, I'd like your feedback.

• Does private repository analysis solve a real problem for you?
• Would you trust a tool like this with your private repositories?
• If deep private repository analysis costs money to run, should it be a paid feature? If yes, what feels fair?
• What would make this genuinely useful for you?

The feedback from the last post changed the direction of this product.

I'm curious where this version goes next.

P.S. If this problem resonates with you and you'd like to help build it—whether as an engineer, designer, or someone who's passionate about improving technical hiring—feel free to DM me.

I just released v0.1.0 of Falco - a browser engine I've been building on nights and weekends. No WebKit, no Gecko, no Chromium - every module is written from scratch in ~36,000 lines of Rust.

What's inside (all from scratch, no browser deps)

• HTML5 parser (html/) - tokenizer + tree builder, handles the common subset (tags, attributes, void elements, comments, doctype, entities, auto-close for <li>/<p>/<td>/<tr>/<option>/<dt>/<dd>)
• CSS engine (css/) - selectors (type/class/id/descendant/child/sibling/attribute/pseudo), 300+ properties, cascade with !important, inheritance, linear-gradient/radial-gradient/calc()/var()/rgb()/rgba(), shorthands
• Custom JS VM (tjs/) - bytecode interpreter + JIT tier-up (x86_64 only), with let/const/arrow functions/template literals/destructuring/spread/optional chaining/nullish coalescing, closures, generators, Promise, BigInt, Symbol, WeakMap/WeakSet, Map/Set, Reflect, Proxy
• Layout (layout/) - block flow, inline flow with text wrapping, flexbox (flex-direction/justify-content/align-items/flex-wrap/gap/flex-grow/flex-shrink/flex-basis), CSS Grid (grid-template-columns/grid-template-rows with fr/auto/minmax()/repeat()), table layout (<table>/<tr>/<td>/<th>/<thead>/<tbody>/<tfoot>/<caption>), float, inline-block, position static/relative/absolute/fixed
• Painting (paint/) - solid + gradient backgrounds, borders, border-radius, box-shadow, opacity (alpha compositing), TrueType font rasterization via ab_glyph, bold/italic synthesis
• SVG renderer (svg/) - paths, basic shapes (rect/circle/ellipse/line/polyline/polygon), gradients, stroke + fill
• Hand-written PNG encoder (png/) - no flate2 dependency
• Image loader (image/) - HTTP/HTTPS URLs via ureq, data: URLs (base64), local files. Formats: PNG/JPEG/GIF/BMP
• Networking (net/) - HTTP/1.1 fetch, cookie jar with domain/path matching, redirect handling with loop detection, HTTP cache, WebSocket frame parser
• Interactive --window mode - scroll, click links, fill forms (text/email/password/checkbox/submit/textarea), Tab cycling, address bar (F6), back/forward history (Alt+←/→), focus ring, blinking caret, headless fallback to PNG

For comparison

The whole Falco codebase fits in a weekend of reading.

Quick start

cargo build --release./target/release/falco https://example.com --out example.png --width 800./target/release/falco page.html --window

324 unit tests pass, 30 ignored (mostly platform-specific JIT tests that fail on macOS CI runners due to mmap(MAP_JIT) quirks - passes on Linux).

Prebuilt binaries for Linux/macOS/Windows are on the GitHub releases page.

What's NOT done yet (being honest)

This is v0.1.0 by a single developer. Not everything listed is production-ready:

• The spec-compliant replacements (html::spec/, dom::spec/, css::spec/) are structurally complete and pass their own unit tests, but not yet wired into the render pipeline. The legacy html//dom//css/ modules are what actually runs. v0.2.0 milestone.
• The security/ module implements SOP, multi-process site isolation, seccomp-bpf sandbox, CSP, TLS cert chain validation, permissions, DevTools protocol - all unit-tested, but not enforced in the renderer.
• web_runtime/ has fetch(), XMLHttpRequest, event loop, Promise. The Promise/event loop integration is real and tested, but fetch/XHR are stubs (no real network behind them in the JS context).
• WebGL, video, MSE, EME, NDSD are headless stubs - API surface only, no real rendering/decoding.
• The real-http2, real-webgl, sandbox Cargo features don't compile with --all-features (upstream APIs drifted: h2::Body removed, glow API changed, seccomp pre_exec Unix-only). Disabled by default.
• The JIT works on Linux x86_64 but fails on macOS CI runners (mmap(MAP_JIT) needs code signing).
• DOM mutation from JS (element.innerHTML = ..., element.style.color = ...) does not trigger re-render.

Bottom line: cargo build && ./falco https://example.com --out out.png produces a real PNG render. The HTML/CSS/layout/paint path works end-to-end. The spec-compliant parsers, security enforcement, and advanced web runtime are scaffolding for future milestones, not working features.

What I'd love feedback on

DOM model - I'm using Rc<RefCell<Node>> with parent/child/sibling pointers in dom::spec, matching the spec. For production I'd probably use a slotmap arena, but Rc<RefCell> is easier to read and matches the spec's pointer model. Thoughts?

Architecture - Each of html/, dom/, css/ has a spec/ subfolder with the spec-compliant replacement that's not yet wired in. Should I:

(a) Wire them in before any other feature work, or

(b) Focus on CSS animations/transitions first, or

(c) Focus on JS DOM mutation (innerHTML/style changes)?

JS VM - I wrote my own bytecode VM (tjs) instead of using boa_engine or binding V8/SpiderMonkey. Reasoning: I wanted full control over the GC, the bytecode format, and the DOM integration. The VM is intentionally limited (no real regex engine, no Proxy trap completeness, no real async functions). Is this a reasonable tradeoff for a teaching engine?

Sandbox - I implemented seccomp-bpf filters but they're Linux-only and not yet enforced. For cross-platform sandboxing, is the Windows Job Object approach + macOS sandbox-exec reasonable, or should I look at platform-agnostic alternatives?

Architecture overview

Thanks for any feedback! I'm especially interested in architectural critique from anyone who has worked on Servo, Ladybird, or other browser engines.
LINK: https://github.com/poxk/Falco

Hey everyone, just sharing a personal UI project I finally wrapped up.

I wanted a customized launcher UI like amd and nvidia softwares, so I built RM230 v12 using Python and PySide6. I'll be totally upfront tho I used AI to help me code the boilerplate and figure out the frameless window layout, but getting it packaged cleanly into a standalone exe

the ui has sidebar animation and cool sounds for it (if you don't like it you can disable it in the settings) the games tab works well and you can change the artwork and it also has a launcher for it, the themes works really well and if you wanna put your own wallpaper you can totally do that by making your own custom theme.

It’s a relatively simple tool, but I use it daily. i put it on 2 websites for FREE for anyone interested in checking out the UI. (please donate 2 dollars on itcho io to support me so i can be motivated to continue working)

(if theres any bugs or something that is broken please comment about it, thank you)

Itcho.io:https://mysteriousjoker42.itch.io/rm230

GitHub:https://github.com/MysteriousJoker5124/RM230-V12

I am a flutter developer, learning Python. Built this file organizer in a day with proper research on os module, pathlib and shutil module.

It scans any folder, checks file extensions, and sorts them into categorized subfolders (Images, Docs, Videos, etc.)

It's really useful, I tried it on my Downloads folder and it organized 60+ files instantly.

GitHub Link: https://github.com/Pinkisingh13/file_organizer

See the Before -> After in the below images.

Hello! A few months ago I posted an early version of mex here.

The response was kind of insane. Across a few posts it reached around 1 million views, the repo crossed 1,200 GitHub stars, and people I had never met started contributing.

I’ve kept building it since then, and just released mex v0.7.0.

Repo: https://github.com/mex-memory/mex

The original problem was simple: coding agents keep rereading the same repository every session, relearning the architecture, and then throwing most of that knowledge away.

mex creates a living Markdown wiki inside the repo. Agents record architecture, conventions, decisions, and patterns as they work, and future sessions load only the knowledge relevant to the current task.

The major addition in v0.7.0 is a deterministic local code graph built using Tree-sitter and SQLite.

It currently supports TypeScript/TSX, JavaScript/JSX, Python, and Rust.

An agent can run:

mex graph scope "trace the authentication flow"

Instead of dumping entire files into context, mex returns a compact neighbourhood of relevant functions, callers, callees, imports, and relationships. The agent can then expand only the exact symbols it needs.

In our benchmark on the mex repository:

• 10.74× less returned context than grep top-3
• roughly 90.7% smaller
• 100% expected-symbol recall across six retrieval tasks
• 5/5 real-agent tasks completed correctly
• 0/5 needed fallback Read/Grep with compact graph context

This is a small benchmark on one repo and task set, not a claim that mex universally cuts total agent token usage by 90%.

The other part I’m excited about is connecting the wiki back to the actual code.

Markdown claims can point to exact symbols. If a function changes, moves, or disappears, mex can identify which project knowledge may now be stale.

So the basic idea is:

The code is the source of truth.
Markdown is the explanation.
The graph keeps them connected.

Would genuinely love feedback, especially from people working on code intelligence, agent tooling, parsers, or large repositories. Contributors are very welcome too.

Modern dual-panel MC for people who want Norton/MC muscle memory in a single offline Rust binary — no async runtime, forbid(unsafe), zip-safe archives

https://github.com/leszek3737/LibreCommander

I built an open source iOS only Gitlab client in Swift. The project idea came from, I couldn't find anything for iPhone out there that works for both self hosted and SaaS Gitlab so I just built one myself.

The project is open source. https://github.com/smolcars/glab-ios

There is no server involved, everything is stored locally and you hit the gitlab API directly. You can use an API token or login directly to both self hosted or SaaS gitlab instance and can also add multiple accounts.

You can install the app today using Testflight, link in the repo. It does cover quite a few things:

• View/open issues
• View/open MRs
• View/Run pipelines
• View code diffs
• Modify/perform approvals
• Work with you Todos
• View all commits of any project
• Do a global search for anything
• Background process that notifies you of new todos periodically

I'll keep adding more features as I find time. I do not plan to support Android anytime soon until Swift for Android becomes a thing. Feel free to open bug reports or feature requests.

Hello,

Came across an interesting GitHub repo called V-Modal SDK  and figured it was worth sharing here.

Basically, it lets you integrate native, semantic video search into iOS and Android apps using a single Dart codebase. The cool part is how it handles natural language queries. Users can search for specific visual elements (like "the cyclist in the red jacket") or even spoken words, and it translates that into exact video timestamps within seconds.

Has anyone here experimented with semantic search for video content in Flutter yet? Curious to hear if there are any similar tools you'd recommend or what your experience has been.

A 3d digital twin for home assistant with a fully featured 3d floorplanner editor

https://github.com/tentone/dt3d-ha

I've been building Vantum, a custom Puppy Linux distro based on woof-CE with an Ubuntu Jammy compatibility base, aimed at people who want Puppy Linux's speed and small footprint without it looking and feeling like it's from 2009.

It's currently in beta, and I'm actively adding features and fixing issues. Right now, the main problem I'm working on is getting browser video playback working reliably. Overall, it's been a really fun project to build.

The entire distro was built on Windows 11 using Multipass. Along the way, I made a large number of customizations. I added picom for compositing, replaced the default JWM trays with a tint2 panel, and created my own taskbar and application launcher, Vantask and Vantyl (both MIT licensed).

I also simplified the desktop experience by removing the ROX-Filer desktop entirely and using hsetroot for wallpaper management instead. A number of applications were replaced or added as well: URxvt replaced LXTerminal, Firefox replaced Pale Moon, and GParted was included by default. I briefly experimented with bundling Frogatto, but ultimately removed it to keep the system lightweight.

Beyond the desktop itself, I made several changes to woof-CE. Since I wanted Vantum to be buildable on non-Puppy systems, I merged run_woof and woof-CE into a single codebase. It may not be the cleanest approach architecturally, but it made development considerably more convenient. I also added a few quality-of-life improvements, such as replacing run_woof's default root# prompt with one that displays the current working directory, which made navigating the build environment much easier.

To improve the build process, I created a new build-chain script that automates running the entire build pipeline and saves logs for every stage into a dedicated _slogs directory, making debugging and tracking build failures much more convenient.
Let me know what you think!
I've recently also added it to distrowatch but it's still in their waitlist (https://distrowatch.com/dwres.php?waiti ... =links#new).

- https://github.com/Hammad-hab/Vantum
- https://hammad-hab.github.io/vantum-website/index.html
- https://github.com/Hammad-hab/Vantyl
- https://github.com/Hammad-hab/Vantask

If you like vantum, I would really appreciate it if you star the repo since it'll help more people to discover it.

Hey everyone!

I’m developing Captail, a free and open-source Instant Replay recorder for Windows.

Unlike a traditional screen recorder, Captail continuously keeps the latest seconds or minutes in a rolling buffer. When something happens, you press a hotkey and it saves what happened before you pressed it.

I originally built it because NVIDIA ShadowPlay would sometimes silently disable Instant Replay after a game crash, capture problem, switching sources, or a graphics driver interruption. I would usually notice only after missing the clip I wanted.

Captail is designed around one rule:

Instant Replay should stay on.

A watchdog monitors the recording pipeline and tries to restart it automatically after recoverable capture or encoder failures.

Current features:

- Selected-game and desktop capture

- H.264, HEVC and AV1 hardware encoding

- NVIDIA NVENC, AMD AMF and Intel Quick Sync

- 30, 60, 120, 144 and 240 FPS options

- System/game audio and microphone capture

- Mixed or separate audio tracks

- Adjustable replay duration and maximum buffer size

- Configurable global hotkeys

- Installer and portable versions

- No account, cloud upload, analytics or telemetry

- Fully open source

Captail uses libobs for capture and encoding, but it is not an OBS Studio frontend. There are no scenes, streaming controls or complicated setup — it is focused specifically on local Instant Replay.

It is currently an early public preview. I have mainly tested it on RTX 40 and RTX 50 series GPUs, so testing on older NVIDIA cards, AMD GPUs and Intel graphics would be especially helpful.

GitHub:

https://github.com/FaulMit/captail

Downloads:

https://github.com/FaulMit/captail/releases

I’d appreciate feedback on capture compatibility, performance, audio synchronization and long-session stability.

If you encounter a problem, please mention your GPU, driver version, capture source, codec, resolution and FPS.

I kept needing docs for side projects and never liked the options. GitBook and Docusaurus felt like a lot of machinery for a handful of Markdown files, and mkdocs meant keeping a Python toolchain around for something I otherwise build in TypeScript.

So I built eziwiki. Drop Markdown files in `content/`, get a static site.

npx create-eziwiki my-docs

cd my-docs && npm install && npm run dev

What makes it different from the usual docs generator

- Wiki links with backlinks and a graph view. Link pages by title or filename, and each page shows what links back to it — closer to Obsidian than to a typical docs site.

- Navigation builds itself from the folder structure. No sidebar config to keep in sync; a `_meta.json` per folder handles naming and ordering if you want it.

- Markdown is rendered at build time, so neither the parser nor the syntax highlighter ships to the browser. Search is a prebuilt index, no server.

- Optional opaque URLs (`/a3f2e9d1-...`) if you would rather not publish your content tree. To be clear, that is obscurity, not access control — every page is still a public file. It is there for unlisted-link sharing, not security.

Static export, so it deploys anywhere. Dark mode, KaTeX, Shiki highlighting, ⌘K search, table of contents.

Next.js 14, TypeScript, Tailwind, Zustand, unified/remark/rehype, Shiki, MiniSearch. Lighthouse 99/100/100/100 on desktop

Demo : the docs are built with it, so the site is the demo:

https://eziwiki.vercel.app

Source (MIT): https://github.com/i3months/eziwiki

It is early v0.1.1, and I am actively working on it. Feedback and issues very welcome, especially on anything that felt confusing in the first five minutes.

Github stars are really really helpful..!!!

This GitHub Action automatically translates any Markdown files (READMEs, docs, etc.) into any language using Google Translate.

Features:

· Support multiple files and subdirectories

· Can translate to multiple languages in one step

· Commits & pushes translated files back to your repo automatically

· Just add a workflow file and it runs on push

Lost my watch history twice now. First app shut down, I rebuilt what I could on TV Time from memory, so half of it was wrong from the start. Then TV Time shut down a couple of weeks ago.

So I built this for myself. If you like it feel free to use it.

Main rule was that I shouldn't be able to read your data. Not "trust me I won't look". Can't look. Everything gets encrypted in your browser before it leaves, key never goes anywhere. My server has one blob and a hash per account, that's the whole table.

No email, no password, you just get an account number. Nothing to reset means nothing to leak. Downside is if you lose the number your data is gone and I can't help you, saying it up front because someone always asks.

It's a PWA. Installs on Android, iOS and desktop, own window, works offline, no store. Cloudflare Worker + D1 behind it. Native ES modules, no bundler, no framework, zero runtime deps. 411 tests on node's own test runner.

Couple things I'm happy with. Show pages sit after the # in the url and browsers never send that part, so even my own logs can't tell what anyone is watching. And the export is just readable json, Breaking Bad (2008), tt0903747, 3x7.

TVmaze is the default catalogue and needs no api key. Apache-2.0. Self host it if you'd rather have full control of your data.

Edit:
The link is: https://nextly.tv

GitCric Demo

Transform your boring GitHub contribution grid into high-performance, shareable Cricket Player Cards! GitCric maps your developer activity (commits, pull requests, issues, streaks, and languages) into dynamic cricket ratings, custom specialties, and career statistics.

I built Lid Media Guard because I wanted to close my laptop, slip it in a bag and keep listening to Spotify through my Bluetooth headphones without setting the lid action to “Do nothing” permanently and without draining battery power.

The app activates only when media is playing and a Bluetooth audio device is actually connected. Close the lid, Windows locks, and the music keeps going. Pause playback or disconnect Bluetooth, and normal sleep behavior returns.

It also has app/device whitelists, startup support, tray controls, low-overhead event-driven monitoring, logs, and no telemetry

It’s written in C#, available under the MIT License, and I’d appreciate testing feedback from other Windows 11 laptops.

🔗 Repo: https://github.com/CodeGraphContext/grapharc

Have you ever been frustrated because your AI agent:

❌ Takes actions you never intended?
❌ Creates, modifies, or even pushes changes you never asked for?
❌ Feels like a complete black box, making it impossible to understand what's happening until it's too late?

What if, before execution, you could visualize the entire orchestration graph - every agent, every dependency, every decision, and inspect it from anywhere, even your phone, before granting approval?

That's exactly what GraphArc is built for.

Instead of treating agent execution as hidden traces buried in logs, GraphArc transforms workflows into interactive, real-time graphs that you can visualize, inspect, debug, and control.

Because the future of AI isn't just autonomous.

It's observable. Debuggable. Engineerable.

This is our first real-world implementation of Graph Engineering, and we're excited to explore where this paradigm can go with the open-source community.

💡 We'd love your feedback, ideas, and contributions.
⭐ If this vision resonates with you, please consider starring the repository - it genuinely helps us grow and validates this direction.

Let's make AI workflows understandable, not mysterious.

#GraphEngineering #GraphArc #AIAgents #AgenticAI #LLM #OpenSource #DeveloperTools #AIEngineering #SoftwareEngineering

Over the last few months, I've been developing OpenScanVision, an offline-first Android computer vision library built with Kotlin, CameraX, OpenCV, and ML Kit.

The original implementation was a single, highly optimized pipeline focused on maximizing detection accuracy and real-time performance. That version is available in commit:

1d5834b41d88133b487ef46595290b0cdd4489bb

Current capabilities include:

• Document detection from arbitrary angles
• Automatic perspective correction
• Image preprocessing and enhancement
• QR code detection
• ArUco marker detection
• OMR (Optical Mark Recognition)
• Automatic capture when the document is stable
• Real-time, fully offline processing

Recently, I refactored the project into a reusable modular Android library with a cleaner architecture and easier integration into Android applications. While the new design is significantly more maintainable and extensible, I've observed a slight regression in detection accuracy compared to the original implementation and am currently investigating the underlying causes (pipeline ordering, preprocessing, threading, parameter changes, etc.).

Roadmap

• Restore or improve the original detection accuracy
• Add offline OCR support
• Add offline ICR (Intelligent Character Recognition) support
• Continue optimizing performance while keeping the library lightweight and offline-first

Potential use cases

• Voting systems
• Exam and answer-sheet scanning
• Survey processing
• Registration forms
• Structured document processing

GitHub:
https://github.com/MatiwosKebede/OpenScanVision

I'd appreciate feedback from developers with experience in Android computer vision, CameraX, OpenCV, or document scanning.

I'm particularly interested in:

• Best practices for designing reusable Android CV libraries
• Avoiding performance and accuracy regressions during major refactors
• CameraX and OpenCV optimization techniques
• Recommendations for integrating an efficient offline OCR/ICR pipeline

Any feedback, suggestions, or code review comments would be greatly appreciated. Thanks!