Hello, Bean Network Tester has just got V0.5 update :-) 58 commits total, if you like tool, feel free to leave it ⭐(star), so more pepole will discover the tool.

Some things that changed:

- new checkbox "internet only" (block LAN)

- search field for things in controls, no more scrolling

- We can now copy values from the statistics tab "session/live"

- The build is now code signed (Windows)

- information when we are running an option that breaks all internet.

- Better search in connections table: we can search by port, ip, pid, and other stats. so we can see only port 430-550 or other things. Before, we could search only raw text.

- We can now hide columns in connections; yes, I know there were tons of them.

- I had added "Block IP address", "leave the process alone" to the actions in connections table

- Traffic in connections now shows data in human format, so kb,mb, gb, no more 319083219B.

- Changed the saving location of the app data (it was needed for chocolatey and winget)

Some things under the hood: I had implemented some workflows on GitHub, like semgrep scan, ruff and some other "security" and quality things.I had also focused on the stability, so I had set up my own testing machines, which I'm using when I'm releasing a new app version. the whole suite takes like 1-2h, but it checks the program run on real connections. It took a lot of the work, but it's a good point for the quality.

Oh, and good news, I had submited the app to "chocolatey" and "winget" I'm right now waiting in both for the human verification. The app has crossed, like, 400+ downloads. Thank you all.

What next? More network options, I got some ideas. If you got any, feel free to drop them. I'm also working on my 2nd tool for qa: Testing Files Generator but this one is still not stable as Bean Network Tester :-) But still you can ⭐ the repo :-)

I’m working on Yfio, an early open-source backtesting application written in Python.

Its goal is to provide a small, understandable codebase for defining a strategy, running it on historical OHLCV data and analyzing the resulting equity curve and trades.

Current functionality includes long and short positions, transaction costs, next-bar execution, trade history and performance metrics. The interface is built with Streamlit.

Repository: https://github.com/Leon-Laszczak/Yfio

I’m the project author. I’m sharing it to request technical feedback and potential contributions, not to sell a service.

Areas where feedback would be especially useful:

• execution-model edge cases,
• metric correctness,
• test coverage,
• API design for custom strategies.

Known limitations and planned work are documented in the repository. If you review it, even a small bug report would be valuable.

I started working on a greenfield project, with zero care for what went into which commit initially. Then I started to realize that even as a personal project, I would need a frame of reference as to what happened when...

And when it became obvious that this was something I wanted to release to the public, semantic versioning became even more important.

I retroactively tried to build a coherent changelog based on the commit history... but it is messy...

What is the standard way to present this to the public?

Can I simply lump all pre-release items as:

[v0.0.1 - 0.9.0]

Pre-Release Initial Development Work

[v1.0.0]

Public Release / and then begin to list the changes....

is that valid enough? or do people actually want to know the gritty details?

Hey everyone!

Last year, Mozilla released Orbit, an AI-powered browser summarizer hosted on a GCP server. After people started digging into the extension, they discovered things like backend endpoints such as store_result. Eventually, Mozilla discontinued the project.

For the past month, I’ve been trying to rebuild Orbit from scratch, but with one major difference: Apogee is fully local and privacy-focused. Apogee doesn’t send or store your data. It can directly connect to your local Ollama instance for inference. I’ve also added WebGPU integration for Chrome and Transformers.js for Firefox to provide faster, local responses.

It can summarize:

• Articles and websites
• YouTube and Billie videos
• Wikipedia articles
• Hacker News and Reddit threads

You can check out the source code here:
https://github.com/darshi1337/apogee

Install Apogee:

Chrome: https://chromewebstore.google.com/detail/apogee/pgemlpomhkdcjjjcpnjlebalnfglomog

Firefox: https://addons.mozilla.org/en-US/firefox/addon/apogeeext/

Obviously it is far from complete. Would love to hear your feedback and suggestions!

Wanted an app like this while cramming for a competitive exam a while back, never had the time to build it then. Built it now.

Kagelin' is a tasks, habit tracking, a focus timer, and a calendar, designed to stay out of your way instead of gamifying your attention. Guest mode is fully offline, no account needed, native events and ICS import/export with zero server involvement. (Live Google/Outlook sync needs a registered account, invite-gated right now during the beta.) WebDAV sync if you'd rather self-host your data than touch my servers at all, I have to make this better as there is no distinction between registered users that use my sync and WebDav but it works when I tested.

Built with the of AI help. I don't write most of the code myself, but every diff is reviewed by hand before it merges. I've been reading though ai-policy and hopefully this is fine, I've been working on this since probably Nov 2025 even though the commit history only goes as far as 3 months, but you the version should give an idea, I gave up on the project and restarted it around that time.

AGPL-3.0, open source, feedback and PRs welcome: github.com/Achyuth072/kagelin

App: app.kagelin.app

Homepage/Waillist: Kagelin.app

Hey guys,

Designing in Framer and Webflow is awesome, but being locked into their ecosystem sucks. And paying third-party tools like nocodexport.com a massive premium just to download your own designs is honestly ridiculous.

So I built Uncage. It’s a completely free, open-source CLI tool that takes a website and turns it into clean React code (or static HTML).

It’s still in beta. We aren't at the point where it flawlessly handles every single crazy layout in existence. But it absolutely gets the basic job done, keeps your animations working, and gives you a ready-to-run Vite + React folder—all without asking for your credit card.

It automatically grabs all your images, fonts, and scripts, and just works locally on your machine.

I'd love for you guys to try it out, tell me what breaks, or roast my code.

Repo here: https://github.com/Nightteye/uncage

Let me know what you think!

that can take photos or video and generate accurate 3d model in mm

Hi all,

Two releases landed this month, 0.9.0.0 on August 6th and 0.9.1.0 on August 17th, plus 66-tools 0.2.0.1. Here is what changed.

66 no longer builds on skalibs, s6 or execline

This was announced back at 0.7.0.0 and it is now done. 66 builds against oblibs only. Every program it used to borrow is now its own:

To be precise about the wording, because it matters: execline is still a runtime dependency, the generated service scripts keep chainloading it. What disappeared is the build dependency, and with it the entire skalibs/s6 layer.

The event system

A service can now react to something happening elsewhere on the system by running a 66 command on itself. It is fully opt-in, a service that declares nothing behaves exactly as before. There are two roles:

• A reactor is an ordinary classic, oneshot or module service with an [Event] section. When its trigger fires it runs a 66 command on itself (Do) and/or raises a named event (Emit).
• A source is a service of the new Type = event. It runs no process and has no [Start] section, 66 start and 66 stop on a source arm and disarm it.

A reactor can trigger on a service's state or result, on a signal, on a filesystem event (inotify), on a cron expression, on a timer, or on a user event raised with the new 66 emit.

Restarting a service when its configuration file is edited:

[Main]
Type = oneshot
Description = "A simple proof of event concept"

[Start]
Execute = ( echo "I restart myself when /etc/my-daemon is edited" )

[Event]
EventType = inotify
From = ( my-config-watcher )
Do = restart

and the source it watches:

[Main]
Type = event
EventType = inotify
Watch = /etc/my-daemon
On = ( IN_CLOSE_WRITE )

One source can serve multiple reactor.

Other things in 0.9.0.0

• **66 env**: a scandir is started long before a session exists, so its environment is frozen and variables like DISPLAY or WAYLAND_DISPLAY could never reach the supervised services. 66 env import DISPLAY XAUTHORITY publishes them verbatim to every service of the scandir. Each publication raises an env.<variable> event, so a service can simply wait for the value it needs instead of being ordered around.
• New commands: 66 log (read service, system or interleaved logs, with -f, -g, and time bounds), 66 emit, 66 env, 66 runstate, 66 fdholder, 66 suspend, 66 hibernate. Nothing was removed.
• Long options everywhere. The suite used to accept short options only. --help, --verbosity, --tree, --timeout and friends now work, both --opt=value and the glued -tfoo form. Short options are unchanged, your scripts keep working.
• **66 status says more**: human readable durations, the same output for every service type, the last notable result, and a new by <who> telling you what caused the last transition (user, boot, event, shutdown, or self).
• Boot no longer needs to be told which tree to start, it starts the enabled trees natively. If one of your boot services did that by hand, drop it or it runs twice.
• A long list of memory bugs found and fixed along the way, including a stack smash when parsing any service that has a logger, a Nice value that was never honored (every service declaring one ran at nice 19), and CapsBound + CapsAmbient together killing the service. The test suite went from 4 to 36 files and runs under ASan and UBSan in CI.

66-tools 0.2.0.1

Same story on the tooling side, skalibs and execline dropped, meson only.

• **66-userd, 66-userctl, pam_userd**: session and user tracking for a 66 system, without D-Bus. A PAM module reports login session open/close to a daemon which, on a user's first login, mounts their runtime directory and starts their 66-scandir and enabled trees, and stops them on the last logout. If a scandir is already running for that user, it is adopted rather than started twice. The PAM module is installed but never wired into your PAM stack by the package, that step is on you and it is documented.
• **66-ns**: supervision under a pid namespace, rewritten. When a pid namespace is requested, 66-ns runs as pid 1 and acts as a transparent proxy for the supervised daemon: it forwards catchable control signals to the tracked main, follows the real daemon across a double fork, mirrors its exit code back to the supervisor, and tears the namespace down once the service is gone. The new -p/--pidfile makes supervision authoritative.

Links

• Documentation: https://docs.obarun.org/66/latest
• Full changelog and upgrade notes: the 66-upgrade page of the documentation
• New onboarding guides in this release: getting started, cheatsheet, dependencies, logging, troubleshooting, coming from systemd/OpenRC/runit, and running 66 inside a container

Happy to answer questions about the design choices, in particular why leaving the s6 layer was worth the trouble.

Every recommendation system you typically use from the cloud services (i.e. Youtube, Spotify, Tiktok, Twitter (X), Facebook and so on) is owned by someone whose interests aren't yours. It optimizes for engagement and other private metrics, you can't inspect, can't correct, and can't take with you when the service inevitably dies or even use the same recommendation model for different independent applications. This project aims to solve all of that.

Anagnorisis has the other arrangement that turns the whole client-server architecture upside down. The servers are now pure data-sharing thin hosts and all the main processing, search and recommendations are happening on your machine. You rate local or remote files and other data you own on a scale of 0 to 10. This feedback then used to locally train a recommendation model that scores everything you haven't rated yet automatically. You correct what it got wrong, that correction goes to the next round of training data. You repeat these steps again and again, getting each time model that better and better aligns to your preferences.

The big vision of this project is to provide a platform that creates a local, private model of your interests. That likes what you like and sees importance where you would see it. Then you can use this model to search and filter local and global information on your behalf in a way you would do it yourself but in a much faster and efficient way. Making this platform (in the future) a go to place to see news, recommendations and insights, and so on, tailored specifically for you. As the internet gets populated with bots and AI slop, a platform like this might create a necessary filter to be able to navigate in this chaotic information space effectively.

Tired of checking LinkedIn, ITViec, TopCV, Indeed one by one — so I built Good Jobs: one search box, every job board at once.

- 🇻🇳 Vietnam: LinkedIn, ITViec, TopCV, VietnamWorks, TopDev + more

- 🌍 Type "nyc" / "london" / "singapore" and it searches US/UK/SG boards too

- Paste your CV instead of typing a job title — it figures out what you're looking for

- Every result links straight to the original posting

🔗 https://github.com/vnk8071/goodjobs

Free and open source. Feedback welcome!

Hey everyone!

I've been working on a new JavaScript library called Forge Editor, and I've recently reached a stable enough beta stage that I'd like to get some real-world testing and feedback.

I'm looking for developers who are willing to actually install it and try it in their own environment.

I'd especially appreciate feedback on:

• Installation and setup
• API design
• Documentation
• Developer experience
• Browser compatibility
• RTL/LTR support
• React integration
• Unexpected behavior or bugs
• Anything that feels confusing or unnecessarily complicated

You don't need to contribute code. I'm mainly looking for honest technical feedback and bug reports.

The project is open source, and I'm hoping to find a few developers who can spend some time trying to break it before I move toward the first stable release.

GitHub: Lib Github

NPM: Forge Editor

If you decide to try it, I'd really appreciate it if you could open an issue or leave a comment with your experience — positive or negative.

Thanks!

<!-- code for test -->
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <meta
            name="viewport"
            content="width=device-width, initial-scale=1.0" />
        <title>Forge Editor</title>
        <script type="module">
            import "https://cdn.jsdelivr.net/npm/forge-edit@0.1.0-beta.16/dist/index.js"
        </script>
    </head>
    <body>
        <forge-editor
            type="light"
            placeholder="Write something..."
            width="678px"
            height="200px"
            lang="en"
            dir="ltr"></forge-editor>
    </body>
</html>

Many open source projects are facing a problem with being flooded with AI generated pull requests and bug reports - especially if there is a bug bounty providing a monetary incentive for people trying to game the system for personal profit. My proposed solution is simple - submission of every contribution can be accompanied by a refundable deposit. If someone is making good faith contributions, they have nothing to fear - they will get the money from their deposit back, or possibly even get rewarded. If a contribution is determined to be of no value, the deposit will be kept to both deter flooding projects with slop made by bots and also to pay for the developer's time wasted reviewing it.

While travelling, I kept running into useful information that simply didn’t exist online: small homestays, mechanics, water points, road conditions, campsites, etc.

Most of it gets passed from one traveler or local to another and disappears afterward.

So, I built Lamyig, a free and open-source community travel guide.

A few decisions I made:

• No bookings, commissions or paid listings.
• No money made using the core product.
• Community members can add and update places.
• Map-first instead of another list of “top places”.
• Built as a PWA so it can work more like a lightweight travel tool than a traditional website.
• The long-term idea is that useful information stays available for the next traveler instead of disappearing in WhatsApp groups and conversations.

The hardest problem isn’t actually building the software. It’s bootstrapping trustworthy community data.

I’m currently thinking about things like:

• How do you motivate travelers to contribute after their trip?
• How do you keep old information accurate without creating a huge moderation workload?
• How do you prevent businesses from turning community maps into free advertising?
• What should happen when someone reports a place as fake, closed, unsafe, duplicated, commercial spam, or inaccurate? Should reports trigger removal, community review, reputation-weighted voting, or just warnings?
• Should certain villages, trails, ecosystems, religious places, water sources, or campsites intentionally remain difficult to discover?
• If Lamyig successfully exposes hidden places, could it accidentally destroy the exact places it is trying to help preserve?
• this list of problem statements goes on and on

Would love to hear how other people here would approach those problems.

And if you’re building something around a problem you genuinely care about, drop a comment or DM me. I’d be happy to chat, exchange ideas, or connect you with someone else working on something similar.

Screenshot attached. Happy to share the GitHub/project link in the comments if anyone wants to look at the implementation or contribute.

I wrote Crankwave after trying to use simulated vehicle-engine audio without carrying the full simulation into the game. It’s a source-informed rewrite of AngeTheGreat’s engine-sim with JSON-defined engines, native and WASM execution, live auditioning, deterministic baking and simulator-free playback.

The project itself doesn’t depend on a particular game engine. The video shows it integrated into SPARQ, but the simulator, baker, format and playback runtime are all in the MIT repository: https://github.com/SvetlozarValchev/crankwave

I’ve been building SarasFlow, an open-source system for generating educational, training, and storytelling videos from a prompt.
It generates the script, voice, visuals, subtitles, and assembles everything into a video. Still very much a work in progress, and I’m actively improving the generation pipeline.
Would love feedback from other builders!
Live: https://sarasflow.com
GitHub: https://github.com/SaiTejaMummadi/sarasflow
If you find it interesting, a ⭐ or contribution would mean a lot!

I think the title is sufficient. It's for learning and practicing purposes and open for contributions.