ivo's home

PySceneDetect v0.7.2 is a CLI and Python library for detecting scene cuts in video files. It uses ffmpeg to split videos based on content-aware or threshold-based detection. The Docker image includes all dependencies for isolated environments.

This is useful if you need to batch process videos for thumbnail generation or dataset creation. It requires ffmpeg installation or a Docker setup, so it is not a zero-dependency tool. The Python API offers more control than the simple CLI commands.

more: https://github.com/Breakthrough/PySceneDetect

my other side: ivo.blogspot.com

This is an open-source fork of mapbox-gl-js released after Mapbox switched to a proprietary license in 2020. It uses GPU-accelerated rendering to display vector tiles on the web. The library is BSD-3 licensed and has evolved significantly beyond its initial goal of being a drop-in replacement for Mapbox 1.x.

It is worth trying if you need a free, community-driven alternative for web mapping. The main catch is that you cannot backport code from the original Mapbox repository due to license incompatibility. It is not suitable for teams relying on Mapbox's specific enterprise support or proprietary data pipelines.

more: https://github.com/maplibre/maplibre-gl-js

my other side: ivo.blogspot.com

Jolt Physics is a rigid body and collision detection library written in C++17. It focuses on high-performance concurrency, allowing simulation updates and collision queries to run across multiple threads without traditional locking bottlenecks. The engine is battle-tested in large-scale titles like Horizon Forbidden West.

If you are building a simulation or game that requires precise multi-threading, this is currently the best-in-class open source option. It is not, however, a general-purpose scientific simulator and makes specific approximations to favor game-like performance over absolute physical accuracy. Expect to spend significant time on the API integration if you are moving away from a simpler library like PhysX.

more: https://github.com/jrouwe/JoltPhysics

OpenIDEA is an open-source, native application that replicates IntelliJ keymaps, tool windows, and search habits using a Rust core. Benchmarked on a 32-core Windows machine opening a 770-file Python repository, it starts in 1.1 seconds and uses 169 megabytes of memory compared to IntelliJ's 13.2 seconds and 2 gigabytes. It includes an editor, debugger, terminal, and database clients for over sixty languages while building on Tauri and Rust.

It is worth trying if you like JetBrains ergonomics but are tired of JVM memory usage and sluggish startup times. The catch is that the analysis engine is not nearly as deep as IntelliJ's, meaning code insight will lag behind on large codebases. This is an early-stage alternative, so expect missing plugins and rough edges if you rely on deep language-specific tooling.

more: https://github.com/l0ng-ai/openidea

my other side: ivo.blogspot.com

Blaze is a drop-in replacement for cargo build and test on macOS Apple Silicon and Linux, keeping projects in memory to rebuild edited functions in milliseconds. It uses its own bundled nightly toolchain and Cranelift to update binaries without relinking from scratch, cutting iteration times by roughly 10x to 20x across projects like ripgrep and helix. The tool also supports hot reloading for running programs on supported platforms.

It trades substantial RAM—several gigabytes per project—for raw speed and uses its own isolated toolchain rather than your project pin. Because it is young and uses non-standard linking, you should keep cargo check or standard CI as your source of truth. It is worth installing if you spend your day waiting on large Rust codebases to relink.

more: https://github.com/indexable-inc/blaze

my other side: ivo.blogspot.com

Rubix is a systems programming language with a compiler written entirely in pure x86-64 assembly. The resulting binary is roughly 42 kilobytes, has zero libc or external dependencies, and compiles source files in under a millisecond. It handles multi-file imports, heap allocation, and standard control flow while targeting Linux, Windows, and macOS.

It is an impressive technical exercise if you want to study low-level compilation and x86-64 mechanics without the weight of LLVM or C. However, it is strictly tied to the x86-64 architecture and lacks the ecosystem maturity required for production software. Skip it unless you specifically want to hack on bare-metal assembly tooling.

more: https://github.com/tek-sys-hub/Rubix-lang

my other side: ivo.blogspot.com

penso/herdr-gpui is a native desktop client built with Rust and the GPUI framework for macOS, Linux, and Windows. Instead of wrapping a traditional terminal emulator, it paints the terminal cells, split panes, and workspaces of a self-hosted Herdr daemon directly on screen. It includes features like remote SSH host tracking, inline image rendering, browser tab annotations, and code navigation that jumps straight to your editor.

It is worth a look if you already run the Herdr daemon and want a dedicated GUI that avoids browser bloat or TUI wrappers. The catch is that it is strictly an unaffiliated client with no backend control, meaning you still have to install and manage the underlying daemon yourself. If you rely entirely on standard terminal multiplexers or web interfaces, the setup overhead will likely outweigh the benefits.

more: https://github.com/penso/herdr-gpui

my other side: ivo.blogspot.com

ShellRS is a cross-platform SSH client written in Rust that combines terminal access, WinSCP-style dual-pane SFTP, and port forwarding into a single GPU-rendered window using Zed's GPUI framework. It stores host configurations in a local SQLite database while keeping passphrases in the system keychain, and includes a CLI to let AI agents run commands on saved hosts without exposing credentials. The app replaces setups that previously required separate tools like Xshell and WinSCP, and it can be launched directly from bastion hosts.

It is worth trying if you manage multiple remote machines daily and want a fast native binary instead of an Electron app. The catch is that several of the more advanced right-sidebar inspection tools are limited to Linux hosts, and it is still a young project compared to established terminal multiplexers. Skip it if you rely heavily on tmux workflows or need a web-based interface.

more: https://github.com/since2006/shell-rs

my other side: ivo.blogspot.com

Tusk is a native database client built in Rust using Zed's GPUI framework. It skips Electron entirely, using GPU-accelerated rendering to keep tables with millions of rows scrolling smoothly while connecting to everything from Postgres to Redis.

It is worth trying if you are tired of sluggish web-view tools and want a keyboard-driven interface with local credential storage. The catch is that it is still young, so you will likely hit missing edge cases depending on which obscure engines or workflows you rely on.

more: https://github.com/alpcanaydin/tusk

my other side: ivo.blogspot.com

This repository by Evangelos Vlachos implements a complete flight-booking system using .NET 10 microservices, Vertical Slice Architecture, and Domain-Driven Design. It combines PostgreSQL and MongoDB stores with EventStoreDB, using RabbitMQ and Wolverine for durable messaging alongside gRPC for synchronous calls. The entire stack includes YARP as an API gateway, Duende IdentityServer, and full observability tooling orchestrated through .NET Aspire or Kubernetes.

It is worth cloning if you need a concrete blueprint for implementing CQRS, event sourcing, and inbox-outbox patterns in modern .NET without resorting to toy examples. The catch is that the architectural overhead is massive for simple applications, making it entirely unsuitable for anything smaller than an enterprise-scale distributed system.

more: https://github.com/evangelosvlachos96-dotcom/booking-microservices

my other side: ivo.blogspot.com