I needed to keep the same business rules running on different targets. AI wasn't solving it consistently, and the solutions I found were too complex to integrate into the lightweight pipeline I was already using. So I ended up building my own some months ago.

Today, JSOL ( currently v0.2.97 ) keeps my AIs in check while compiling 70+ examples and even itself to JavaScript, TypeScript, PHP and Python.

JSOL uses a deliberately simple syntax, a set of standard functions designed to remove ambiguities between languages, and contracts to ensure the compiled code produces the same results on every target.

Should you bother learning it?
Probably not.

But you don't have to learn it: you can point your AI to the language spec and let it do the work. What you get in return is an extremely lean pipeline that verifies the result is still bit-for-bit identical across every target.

If you need to maintain business rules across several targets, give it a try.

i want to find software that lets me change volume and other settings of my computer in a simple way

windows settings is not good enough for what i would want its not perfect i would want something better does something better thats FOSS exist?

mini-AGI - is a continual learning byte-level language model that assembles its own architecture, trains from scratch on a single 8 GB VRAM GPU, and keeps learning from everything it reads. It stores its weights as ordinary files on disk and pages them onto the card as it needs them, so the parameter count is bounded by free disk space rather than by VRAM. It grows new capacity while training when it runs short, prunes what nothing asks for, and reads through exactly the same code path it serves on. Targeted at a PC or laptop with at least an 8 GB VRAM GPU on the board.

All technical details, weights and benchmarks are available on the github page.

The project is heavily AI assisted. And I am pretty sure a project like this would be practically impossible without heavy use of AI or thousands if not millions of dollars spent on research. And there is no interest for any big company to work out something like this, as it gives complete control and privacy to the end user without any commercial potential to eventually monetize the project.

Hi everyone, If you use Rust in your projects

Last week I published a shared build cache manager that handles compiled dependencies and Cargo’s artifacts inside a shared directory. The idea is simple: why recompile the same dependencies every time? epicenter takes advantage of the “freshness” rules Cargo uses when compiling a project and lets you reuse what’s already built. No wrapper, no `RUSTC_WRAPPER` like kache or sccache.

These are some benchmarks on 5 test projects with 37 dependencies (best case: a monorepo with a shared platform crate): five cold builds went from 71.3 s to 15.3 s, and disk usage dropped from 3.65 GiB to 0.91 GiB.

epicenter is a state layer for Cargo builds. It uses features of Cargo that for some reason are not enabled by default, like a shared build directory, and rust-lld instead of the default linker (unfortunately this can’t be used on macOS, because ld64.lld is not a drop-in replacement for Apple’s linker). It manages everything as three tiers: a durable vault (store) of compiled units that survives `cargo clean`, the shared build dir that every project compiles into, and disposable per-job work dirs seeded from the vault.

**How is this different from sccache or kache?** They are rustc wrappers: they cache compiler outputs keyed by their inputs, but Cargo still invokes rustc (through the wrapper) for every unit, and each project’s `target/` gets its own copy of the artifacts. epicenter works one level above, on the state Cargo itself uses to decide that a unit is Fresh. Restored units never reach rustc at all, and files are hard-linked rather than copied. It’s a different approach to the same problem, and the two can even be combined if you want.

I also developed it to help everyone writing Rust with agents who need different workdirs without creating a worktree for every feature. epicenter lets you create per-job build dirs seeded from the vault, without Cargo locking them and without duplicated dependencies. It also manages the dependencies for you: you can see what’s in the cache, prune old stuff by age, or evict a specific crate or a stale toolchain generation, with a dry run first so nothing gets deleted by surprise.

It’s built to be plug and play: run `epicenter setup` (or `epicenter setup --fast`) once, then keep building like always. It works with both stable and nightly toolchains. Linux/WSL and Windows are verified, while macOS is only compile-verified for now, so if you’re on a Mac I’d really appreciate it if you tried it and told me what breaks.

*Requires Rust 1.91+.*

[https://crates.io/crates/epicenter-cli\](https://crates.io/crates/epicenter-cli)

[Git repo](https://github.com/TheAnalist/epicenter)

I created an open-source gateway that reduces LLM API costs through zero-latency in-memory caching, payload compaction, and sub-millisecond model routing.

No external frameworks or packages used — just pure Go standard library and a single static binary.

Repo & docs: https://github.com/alexpatil/sukami

Feedback and edge-case suggestions are very welcome!

Hey everyone!

I got tired of opening heavy, ad-cluttered browser tabs with popups just to check live football scores while working, so I built Kickoff: a fast, keyboard-driven football scoreboard that lives directly in your terminal.

Highlights:

• Live Scores & Fixtures: Real-time match clock, scores, and status across top international leagues.
• Detailed Match Views: Live statistics (possession, shots, fouls) and tactical lineups.
• Instant Match Viewing: Follow the live text stats, or jump straight into the broadcast in mpv with a single keypress 📺
• Vim-friendly Navigation: j/k controls, tabs, and a quick league switcher.
• Lightweight & Fast: Single standalone binary, quick startup, and a small memory footprint (~25-30 MB RAM).

Supports both English and Spanish out of the box.

GitHub Repository:
https://github.com/e12jassir/kickoff-cli

Pre-compiled binaries for Linux, macOS, and Windows are available on the GitHub Releases page. Just grab the one for your OS and you’re good to go.

Installation with Go:
go install github.com/e12jassir/kickoff-cli@latest

Feedback, feature ideas, and contributions are very welcome!

I'm the original author. And just kidding, I'll keep up development as always regardless of stars.

This project was hand written for many years. I've now incorporated AI to flesh out new features, review PRs, manage Github issues and run periodic security & QA audits.

We have a great community of users and would love to have some of you. Features & ideas always welcome. (Github stars too!)

https://github.com/pglombardo/PasswordPusher

You can self host, use a 1-click deploy or try https://oss.pwpush.com.

Possibly helpful:

• Trust is a concern. Why should I trust and use Password Pusher?

• What are the potential security risks of running my own version internally?

I had just released Naughty Keyboard, it's a tool for testing input fields, the design is simple.

The app comes with values packs, each value pack is a set of problematic data, with one shortcut we can write the problematic data, with other we can switch the pack, the app is cross-platform, full GUI + CLI (there is nkb emit, so we can export the values and use in own tests form the code). Like the project? Please give it a star. GitHub

Right now there are 208 values, and packs like export breakers, extreme numbers, some specific data, in the future there are plans for 1000+ values, you can read here: full list of packages. Like I said it's simple, keep it in background, use when needed, in the feature I will expand the ability for creating own packages and shortcuts, let's say we would automate whole input fields on website with one shortcut :D And I think the tool can automate some boring work too, because right now I'm using the copy/write mode for testing values, but if in easily way other pepole could create own packs for work, so there is potential.

I won't lie that all works perfect, I tested it on systems I got, but there are some known bugs that I'm fixing right now :-)

Please, don't ask me about some girls emojis or anything like that, the "naughty" in the name is in sense of "testing" not some girl things :( You now like a big list of naughty strings.

Full features list:

• One shortcut, one value - Alt+Shift+N (Option+Command+N on macOS, Ctrl+Alt+N on Linux) clears the line and types the next value of the current pack into whatever window has the keyboard. Previous and restart are one chord away, and every chord can be changed.
• Values that explain themselves - each one carries breaks (what it usually breaks, and why) and expect (what a correct application does). The pack file, nkb show and the report block all say so.
• Invisible characters made visible - the palette draws one as a marker, ␣, instead of showing nothing, and counts every value four ways: graphemes, code points, bytes and UTF-16 units.
• Know where you are - the palette shows the value that comes next and a counter of how far through the pack you are, and the value window searches the values of every pack at once.
• A bug report in one chord - Alt+Shift+B copies a block for the last value: which value, from which version of the pack, typed as what, how large, and whether all of it arrived. The value is written in a form someone else can type back, never as the marker the palette drew.
• Never takes the keyboard - the palette is a display driven by shortcuts and does not take focus, so the cursor never leaves the field you are testing.
• Clipboard mode - put values on the clipboard to paste yourself, for one window or for all of them.
• Packs you can check - a pack is a plain TOML file, nkb lint checks it against the format rules, nkb fmt puts it in canonical shape, and nkb new-pack writes the skeleton.
• Made for scripts too - nkb emit prints a pack as JSON, CSV or one value per line, escaped or raw, optionally as base64. Every command has exit codes you can branch on.
• Offline, free, no telemetry - GPL-3.0, no account, and it opens no network connection.

The technologi is Rust + slint.

Hey Reddit!

I wanted a clean, free tool to turn my music tracks into neon visuals and quick TikTok/Shorts teasers without paying for expensive subscriptions. Since I couldn't find exactly what I needed, I decided to build it myself.

The catch? I’m a solo developer from Ukraine, and my current hardware is a low-end Pentium PC with only 4GB of RAM. Building a desktop app with Electron, Node.js, and FFmpeg on this machine is an absolute battle.

Since I'm a solo dev, I used AI as my virtual "Junior Developer" to help me speed up the coding process, write tests, and optimize performance for my weak hardware. Every time I hit "Export MP4", my CPU hits 100% and my PC literally screams. But it works!

Key features of PulseFrame Studio:

Wizard Mode: Simple 5-step workflow to drop your audio and cover art.

Full Editor & Timeline: Audio-reactive Neon Wave spectrum, intro/outro scenes, and FX markers.

Beat-Driven Edits: Cut and sync videos to the beat.

Shorts/TikTok Teaser Maker: Separate editor for vertical 9:16 videos (10-30 seconds chunks) with flash effects.

100% Free & Open Source: MIT License, no subscriptions, local-first.

Why I’m sharing this:

Because of my weak hardware, I can't fully stress-test the MP4 export feature with heavy video files. I would love for you guys to check out the code, run it on your machines, and give me some feedback or bug reports!

Website: pulseframe.tihsmile.space

GitHub: https://github.com/pulseframeops/studio

P.S. If you like my dedication and want to help me buy a RAM upgrade (or a budget smartwatch so it vibrates every time my Electron app crashes, lol), I’d be incredibly grateful for a coffee: ko-fi.com/tihsmile

I have a work and a personal Claude subscription and switching between them kept breaking my flow. I had to log out, log in, then type /status to check which account I'm on etc.

So I built csw (Claude Switch), a small CLI where each account keeps its own login, while your settings, skills and CLAUDE.md stay shared.

Optionally it also shows which account you're on right in Claude Code's status line.

Your existing ~/.claude stays your main account. csw never deletes and never touches your credentials. Logins go through Claude's own /login flow

Install it with brew (macOS/Linux) or scoop (Windows): https://github.com/georgetsouvaltzis/claude-switch

Free and open source. Feedback is more than welcome!