Design
Preset
Background
Text
Font
Size
Width
Account Pricing

The Git Times

AI Models
Claude Opus 5.5 $20/M —GPT-6.1 Sol $10/M —Gemini 4 Argon $10/M —Grok 4.7 $6/M —DeepSeek V4 Pro 0813 $1.98/M —Qwen3.8 Max Prime $12/M —Kimi K3 $11.94/M —
Full Markets →

Mistral's Timestral Forecasts Time Series on a Laptop CPU 🔗

Four model sizes from 5M to 209M parameters claim top benchmark rankings, with probabilistic forecasts over multivariate data and covariates.

mistralai/timestral · Python · ▲ 70 in 1d 6d old

Timestral is Mistral AI's family of time-series foundation models, built for multivariate probabilistic forecasting. Its standalone inference repository lets developers run predictions without training anything, using only PyTorch, NumPy, safetensors and huggingface_hub.

The approach is what makes it worth a closer look. Rather than fitting a separate model per dataset, a single pretrained model forecasts zero-shot, the way language models answer prompts without task-specific training. Key capabilities include:

  • Joint forecasting: the variates of a series are predicted together, not one at a time.
  • Covariates: past-only, known-future and categorical inputs are all supported.
  • Probabilistic output: 21 quantiles per time step, so teams get uncertainty ranges, not just point estimates.
  • Long context: up to 32,768 steps of history.
  • CPU-friendly inference: no GPU is required, lowering the barrier for small teams.

Long horizons are handled block by block, with each block's median fed back as context. Missing values are marked as NaN or through an observation mask.

According to the launch materials, the 209M-parameter model ranked first among pretrained and zero-shot models on GIFT-Eval, TIME and fev-bench. The four sizes also sit on the accuracy-versus-size Pareto front, which means no smaller model in the family is beaten on accuracy at its footprint. Those benchmark claims come from the vendor and have not been independently reproduced here.

The code is Apache 2.0, while the weights are released separately under a Modified MIT license, so read both before commercial use.

The catch: The repository is brand new, with five open issues and no tagged release, and the benchmark rankings are self-reported at launch. Teams should validate accuracy on their own data and check how the weights' license applies to their use case before building on it.

Use Cases
  • Demand planners forecasting inventory across many product lines at once
  • Energy analysts producing probabilistic load forecasts without GPU infrastructure
  • Data engineers adding zero-shot forecasting to existing monitoring pipelines

Source: mistralai/timestral — based on the project README.

More on the Front Page

EAGLE-4 Sizes Speculative Decoding to Each Workload, Keeping Output Exact 🔗

The drafter tunes its speculation tree to the batch size, hardware and workload, and serves Qwen3.8-27B on SGLang, vLLM and TokenSpeed.

eagle-hq/EAGLE-4 · Python · 600 stars 0d old

EAGLE-4 is a new inference drafter for accelerating large language models. Its distinguishing feature is that it does not use a fixed speculation setting.

Instead, it sizes the speculative tree from measured draft and verification costs for the batch size, hardware and workload it is actually running on, while preserving the target model's output distribution.

The EAGLE-4 draft combines three components: a sliding-window draft layer, a low-rank candidate head and an append-only draft cache. Dense and latent-MoE draft structures are both implemented. The measured target pair is Qwen3.8-27B with its EAGLE-4 draft.

The eagle-harness package, installable from PyPI, serves these drafts on SGLang, vLLM and TokenSpeed. It attaches through hooks the engine already exposes rather than patching the engine at runtime. Stock engine packages do not carry those hooks, so builders must install pinned, patched engine wheels or container images. The release settings file holds every version pin and index URL, and the v0.1.0 release attaches the wheels directly.

Benchmark results are reported per engine against a matched no-speculation control, with conditions stated for each row. No TokenSpeed throughput is claimed.

The catch: This is a first public release, v0.1.0, with the throughput claims resting on a single model pair and a specific GPU configuration (4× NVIDIA B300). The engine dependency means adoption requires maintaining patched builds of SGLang, vLLM or TokenSpeed, which will track upstream only as quickly as the pins are updated.

Use Cases
  • Inference engineers serving Qwen3.8-27B who want faster generation without output changes.
  • Platform teams running SGLang, vLLM or TokenSpeed clusters seeking adaptive speculative decoding.
  • Researchers benchmarking dense versus latent-MoE draft structures for speculative decoding.

Source: eagle-hq/EAGLE-4 — based on the README and release notes.

Open Design Lets Teams Share, Review and Refine AI-Built Prototypes 🔗

Reviewers can comment on live work in a browser, and feedback syncs back to an agent for revision.

nexu-io/open-design · TypeScript · 103k stars 5mo old

The latest release, `open-design-v0.26.

0`, adds a shareable link for work-in-progress. Signed-in reviewers can open an interactive design or motion video in a browser, without installing the desktop app, and leave comments on specific elements.

Those comments sync back into the project. Teams can select the feedback they want acted on and hand it to an agent, then review the result in the same workspace.

Motion Design now appears on Home and in Community, with editable sources that export to MP4. Shared pages show the work and its comments, not the project's AI conversations or code.

The workspace is Apache 2.0 and local-first, and it connects to dsh (DeepSeek Harness), Claude Code and other coding agents.

The catch: the repository carries 1,233 open issues, and the review loop is new enough that teams should test it on their own projects before relying on it.

Use Cases
  • Product teams sending interactive prototypes to clients for in-context comments.
  • Marketing teams turning motion briefs into MP4 videos with agent help.
  • Design leads iterating on brand systems with coding agents in a shared workspace.

Source: nexu-io/open-design — based on the README and release notes.

Offline-First Rust Office Suite Keeps Your Files in Your Folders 🔗

Apps run without an account or cloud service, and macOS builds are notarised by Apple

ELY-Open-Source/ElyOffice · Rust · 686 stars 1d old

ElyOffice is a set of desktop document apps written in Rust on the GPUI toolkit. The apps work offline and store files directly in the folders you choose.

No account, no cloud sync.

The project ships ElyDoc, ElyTable and ElyShow, covering documents, spreadsheets and presentations. Its macOS packaging script builds .app and .dmg bundles, plus source archives that include patched MuPDF and Git.

The latest release, v0.1.9, fixes Windows clipboard paste, a spreadsheet AutoFilter crash and selection colours in some themes. Code moved to GitHub under the MIT licence, with bundled engines keeping their own licences.

The catch: Linux and Windows packaging recipes have not been run on those systems, and the project has 17 open issues and a young 0.1.x version number.

Use Cases
  • Privacy-minded writers keeping documents in local folders without cloud accounts.
  • Rust developers studying an offline desktop app built on GPUI.
  • Small teams needing offline spreadsheets and slides on macOS without subscriptions.

Source: ELY-Open-Source/ElyOffice — based on the README and release notes.

Agent-Driven E2E Framework Replays Recorded Tests Without Model Calls 🔗

New `@e2e-dev/testmu` package runs mobile targets on TestMu AI emulators, simulators, and real devices

tester-army/e2e · TypeScript · 11.6k stars 3mo old

The e2e framework lets teams describe a test goal in plain language, then has an agent drive a web or mobile app to reach it. Assertions and locators sit alongside those steps in the same test.

The efficiency trick is recording. Once an agent step is verified by a later assertion, its actions are saved. Subsequent runs replay them with no model calls until the app changes. Tests with no agent steps need no model at all.

The newest change is the @e2e-dev/testmu package. It routes a mobile target to TestMu AI (formerly LambdaTest) Android emulators, iOS simulators, or real devices, one per worker slot. Each attempt can link to a video of its session.

Setup is handled by npx e2e init, which picks an engine and a model provider. Nine example projects, from Vite to Flutter, ship as standalone suites.

The catch: the project is pre-1.0, so APIs and config can change between minor releases, and it has 97 open issues.

Use Cases
  • Mobile QA engineers running Android and iOS suites on TestMu AI devices
  • Web teams replacing brittle selectors with natural-language test goals
  • CI maintainers cutting model costs by replaying verified agent runs

Source: tester-army/e2e — based on the README and release notes.

Prompt Pack Teaches AI Agents to Reverse Engineer Any Software 🔗

REAP gives coding agents ready-made prompts for inspecting binaries, firmware, games, APKs and websites, with 183 forks in days.

JoasASantos/REA-Prompts · Unknown · 1.2k stars 1d old

REAP is a curated prompt collection for REA, a toolset that lets an AI coding agent inspect how software works. The prompts cover native binaries, firmware, kernels, Electron apps, APKs and websites.

The design is deliberate. Each prompt targets one feature, because narrow questions get evidence-backed answers. The prompts also require the agent to separate confirmed facts from hypotheses and to cite evidence.

The repository is built around clean-room methodology: extract behavior, not code. It explicitly bars copying proprietary source, assets or licensing mechanisms.

Scope is set out in the README. Prompts for anti-cheat, DMA, DRM and vulnerability analysis are framed for security research, CTFs, bug bounties and testing one's own software.

  • Pasted into Claude Code or similar agents, prompts run without rewriting
  • Prompts for Electron apps and APKs cover common desktop and mobile targets
  • Reference material lives at rea.tools and madewithrea.com

The catch: The repository is days old with no open issues, so it is untested at scale, and nothing in its data shows whether the prompts hold up beyond the examples its author chose.

Use Cases
  • Security researchers inspecting firmware and binaries during authorized CTF work
  • Developers analyzing Electron apps and APKs they own for interoperability
  • Engineers hardening their own products by studying how protection schemes detect tampering

Source: JoasASantos/REA-Prompts — based on the project README.

Brazilian Law Corpus Turns Every Federal Statute Into Searchable Markdown 🔗

Repository holds 323,849 norms, each committed in order and signed by the official who enacted it.

ctresb/leis · Unknown · 603 stars 6d old

The ctresb/leis project converts Brazil's Constitution and federal, state, district and municipal norms from official sources into plain Markdown. Each text carries a structured header linking to its origin.

The git history doubles as a legislative timeline. The 323,849 norms in the base set entered one per commit, attributed to the authority that promulgated them and dated to their approval.

The stated goal is wider:

  • Laws, decrees and agency regulations
  • Internalized treaties and binding case law
  • State and municipal statutes

A PROGRESSO.md file tracks coverage item by item, and estatisticas.html offers single-file charts by state, decade and theme.

The catch: texts are automated conversions and OCR of scanned documents, and the project explicitly disclaims substituting the Diário Oficial, so every citation needs checking against the source.

Use Cases
  • Legal researchers searching Brazilian statutes offline in plain text.
  • Civic developers building citizen tools on open, unlicensed legislative data.
  • Journalists tracing which officials signed specific norms, and when.

Source: ctresb/leis — based on the project README.

Free Open-Source App Turns Spare iPhones and iPads Into Mac Monitors 🔗

OpenDisplay offers true screen extension over USB or WiFi with no subscription, dongle, or shared Apple ID.

peetzweg/opendisplay · Swift · 5.8k stars 4mo old

OpenDisplay lets a Mac treat an iPhone, iPad, or spare Mac as a real second monitor. Windows can be dragged onto the device and arranged in System Settings, rather than merely mirrored.

The project positions itself against Apple Sidecar, which requires a shared Apple ID and excludes iPhones, and against Duet Display, which has moved to a subscription. Luna Display needs a hardware dongle.

Key features in the latest release, v1.25.0:

  • USB streaming over the existing cable for lowest latency
  • WiFi discovery via Bonjour, with no configuration
  • Retina output matched pixel-for-pixel to the device panel
  • Touch input and trackpad-style two-finger scrolling

Version 1.25.0 added per-device display sizing and fixed small-iPhone scaling. The project has 172 open issues, and the last commit landed today.

The catch: It is a four-month-old project with 172 open issues, so builders should test their specific device and cable setup before depending on it.

Use Cases
  • Developers adding a spare iPad as a Mac monitor without subscriptions
  • Designers using an old iPhone as a portrait preview display
  • Students extending a MacBook screen with a retired iPhone over USB

Source: peetzweg/opendisplay — based on the README and release notes.

Open Source's Web Layer Splits Into Specialized Tools for Every Request 🔗

From Rust linters to OCaml servers and Zig event loops, the stack is fragmenting into focused, composable pieces.

Trendweb-frameworks
RDFLib/rdflibdagger/daggercomarkdown/comarkTanStack/queryLemmyNet/lemmy-uiLetsFG/LetsFGexcon/exconcamlworks/dreamtester-army/e2eLimeSurvey/LimeSurveymakecindy/cindybiomejs/biomeGoogleCloudPlatform/generative-aiNaiboWang/EasySpiderchaitin/SafeLinecurl/curlmitchellh/libxevjstrieb/github-statsbkaradzic/bgfx

The web-framework corner of open source is no longer one monolith. This cluster shows a pattern: teams are rebuilding each layer of the request path as a small, sharp tool that composes with others.

Tooling has moved to native speed. Biome ships a formatter and linter in Rust, exposed through both CLI and LSP, replacing a chain of JavaScript utilities. On the transport side, curl keeps extending its protocol surface while libxev delivers an io_uring/epoll/kqueue event loop with both Zig and C APIs, aimed at embedding inside other runtimes.

Frontend data handling is splitting by framework. TanStack/query now targets React, Solid, Svelte and Vue from one core, and Comark streams AI output into the same component models, treating model responses as incremental UI state rather than final strings.

Security and testing are following the same modular logic. SafeLine runs as a self-hosted reverse-proxy WAF written in Go, while tester-army/e2e pushes end-to-end testing toward web and mobile from one framework.

The catch: most of these projects are individually strong but do not yet interoperate by design, so "composable" often means glue code. Several agent-oriented entries, such as Cindy and LetsFG, are early and their reliability claims are largely self-reported. Expect consolidation before the modular stack feels settled.

Use Cases
  • Frontend teams replacing ESLint and Prettier chains with Biome.
  • Framework authors sharing one data-fetching core across React and Vue.
  • Self-hosted operators placing SafeLine in front of internal web apps.

Open-source data infrastructure is converging on versioned, event-driven, and AI-ready pipelines 🔗

Catalogs with Git-like branching, declarative orchestration, and RDF knowledge graphs now sit alongside annotation and streaming-ML tooling in one cluster.

Trenddata-infra
xiaoyang111222/cn-math-taxonomyRDFLib/rdflibkestra-io/kestracomarkdown/comarkTanStack/querya-r-j/grapheincvat-ai/cvatprojectnessie/nessieLimeSurvey/LimeSurveyhpcaitech/ColossalAIgoogle-ai-edge/mediapipestefan-jansen/machine-learning-for-tradingNaiboWang/EasySpiderobsproject/obs-studiocurl/curl

The cluster points to a shift in how open-source data infrastructure is being assembled. Rather than monolithic data platforms, projects are composing small, specialized layers that each treat data as something versioned, orchestrated, or semantically described.

Versioning is moving into the catalog. projectnessie/nessie brings Git-like branches and commits to data lakes, letting teams stage and roll back table changes the way they do code. On the orchestration side, kestra-io/kestra runs event-driven scheduling for mission-critical workflows, while RDFLib/rdflib supplies the semantic layer, representing information as RDF graphs that machines can query and reason over.

Data quality is being pushed upstream into labeling and curation. cvat-ai/cvat now combines AI-assisted annotation with QA and developer APIs across image, video, audio, and 3D, and xiaoyang111222/cn-math-taxonomy builds a 1,503-point knowledge graph with adaptive diagnostics for curriculum data. a-r-j/graphein applies the same graph-first idea to protein structures.

On the consumption side, comarkdown/comark streams AI output into rendered components, and TanStack/query manages server state for the front ends that read these pipelines.

The pattern: data infrastructure is becoming versioned, declarative, and graph-shaped, with AI assistance embedded at the labeling and rendering edges.

The catch: Most of these projects are young or narrowly scoped, and the Git-for-data idea has not yet been proven at production scale across heterogeneous teams. Integrating catalogs, orchestrators, and semantic layers still requires significant glue code, so the convergence described here is more an architectural direction than a settled stack.

Use Cases
  • Data engineers versioning lakehouse tables with branch-and-merge workflows using Nessie.
  • Annotation teams labeling video and 3D datasets with AI-assisted QA in CVAT.
  • Platform teams orchestrating event-driven pipelines with Kestra across mission-critical systems.

Open Source Agents Are Moving From Chat Windows Into Production Pipelines 🔗

Repos this week span agent runtimes, inference acceleration, RL fine-tuning, and streaming renderers, signaling LLM tooling is consolidating into a shared open stack.

Trendllm-tools
JoasASantos/REA-Promptsalchaincyf/huashu-motioneagle-hq/EAGLE-4VITASID57/bluntcore-intimacy-labhuggingface/trlcomarkdown/comarkparadigmxyz/centaurnexu-io/open-designmakecindy/cindyGoogleCloudPlatform/generative-ai

A cluster of fresh open-source releases shows where LLM tooling is heading: away from single chat interfaces and toward agents that generate, render, and iterate on real artifacts. alchaincyf/huashu-motion now lets a coding agent produce launch-style video from a prompt, with users pointing at a frame to request edits.

nexu-io/open-design ships a local-first workspace where teams and agents co-edit prototypes, dashboards, and decks. makecindy/cindy and paradigmxyz/centaur package agent runtimes meant to run on infrastructure users control rather than a hosted API.

The supporting layer is maturing too. eagle-hq/EAGLE-4 publishes inference code for speculative decoding, targeting faster generation. huggingface/trl continues to expose reinforcement learning for transformer training, while comarkdown/comark addresses a quieter problem: rendering streamed model output with components and attributes across React, Vue, and the terminal. Prompt collections like JoasASantos/REA-Prompts show agents being scripted for reverse engineering tasks.

Together, these projects suggest open source is converging on a stack: local runtimes, streaming output formats, fine-tuning hooks, and agent workspaces that treat the model as one component among many.

The catch: Most of these repos are weeks old and lack independent benchmarks, so claims about speed and quality remain self-reported. Fragmentation is high, with overlapping agent frameworks competing for the same role, and several projects are thin wrappers around hosted models. Whether this becomes a durable open stack or a burst of demos is unproven.

Use Cases
  • Indie founders generating launch videos from prompts without hiring editors.
  • Design teams co-iterating on prototypes inside a local-first shared workspace.
  • ML engineers fine-tuning transformer models with reinforcement learning on owned hardware.

Quick Hits

wp2shell-PoC Chains two CVEs into a working remote code execution exploit against WordPress, offering a Python proof-of-concept for security researchers to study and test defenses. 562
ascii-sharks Provides TypeScript components that render ASCII-art sharks, handy for adding playful terminal or web decorations to developer tools and docs. 660
Who shipped it

The Business Desks

Fresh on Hugging Face

Model Drops

The newest model releases builders are picking up right now.
Beyond GitHub

The AI Wire

What builders are reading today — the headlines, papers, and announcements that aren't trending repos.

From the labs & arXiv

OpenCV 5.0 Ships Major Revision to the Computer Vision Library Builders Rely On 🔗

The new major version arrives with a published migration path from 4.x and fixes for Android 16KB page alignment.

opencv/opencv · C++ · ▲ 26 in 1d Est. 2012 · Latest: 5.0.0

OpenCV has released version 5.0.

0, a major-version bump for the C++ library that underpins image processing and computer vision work across industry and research. Teams on the 4.x line now face a migration decision.

The project publishes a dedicated 4.x-to-5.x migration guide and a separate overview of the release. Builders planning an upgrade should start there rather than assuming drop-in compatibility.

Two platform notes in the release matter for shipping teams:

  • Android: The original Android SDK was built with an older NDK and a standard C++ library not aligned for 16KB memory pages. Google Play releases should use the package with the 16kb-page-fix suffix.
  • Windows on Arm: Binaries were validated on Qualcomm Snapdragon devices. Some devices with private L2 caches and PPL auto-partitioning may fail, and the project recommends building with OpenMP instead.

The codebase is actively maintained, with the most recent commit landing in the last day. The project spans deep learning, image processing, and classical vision, so the 5.0 changes reach a wide range of downstream code.

The catch: The project carries 2,831 open issues, a volume that signals a large backlog. Teams with pinned 4.x pipelines should test the migration on their own workloads before relying on 5.0 in production, and should verify Windows-on-Arm behavior on their specific hardware.

Previously in The Times “covered” — Oct 19

Use Cases
  • Mobile developers shipping Android computer vision apps to Google Play with 16KB page support
  • Windows-on-Arm engineers deploying vision workloads on Qualcomm Snapdragon hardware
  • Existing OpenCV 4.x teams planning a migration using the official upgrade guide

Source: opencv/opencv — based on the README and release notes.

More Stories

Caveman Agent Cuts Coding Tokens 65% by Talking Like a Caveman 🔗

Version 4.0 splits the tool into six switchable parts; 4.0.1 patches Windows, sync and OpenCode bugs.

JuliusBrussee/caveman · Go · ▲ 238 in 1d 6mo old

Caveman, a Go-based skill and proxy for coding agents, strips filler from model output and cuts token use by roughly 65 percent. Its maintainers say the terse style keeps code exact while the model's reasoning stays intact.

Version 4.0 reorganizes the project into six parts, each with its own switch. caveman status shows what is active, and caveman off disables a single part. Install runs through one command on Mac, Linux and Windows and needs Node.js 22.13 or later.

The 4.0.1 patch fixes a Windows uninstall bug that left a hook in Claude Code's settings, and a caveman sync failure on large span backlogs. It also corrects mode handling on OpenCode 2 and a double-load on Pi. One known sync issue, a rejected findings request, sits on the Caveman Cloud side.

The savings figures come from the project's own tests, though it cites Adobe Research and JetBrains A/B work.

The catch: the 65 percent figure comes from the project's own benchmarks on specific coding tasks, and 76 open issues suggest the six-part design is still settling.

Previously in The Times “covered” — Oct 15

Use Cases
  • Developers running Claude Code who want lower per-session token bills.
  • Teams using Codex or Gemini CLI seeking shorter, cheaper agent replies.
  • Tool builders testing prompt-compression layers on coding agents before production rollout.

Source: JuliusBrussee/caveman — based on the README and release notes.

Colossal-AI Cuts Costs of Training Large Models With Parallelism Tools 🔗

Benchmarks show NVIDIA B200 gains of 50 to 70 percent in throughput for Llama-style training runs

hpcaitech/ColossalAI · Python · ▲ 2 in 1d Est. 2021

Colossal-AI, a Python framework from hpcaitech, is aimed at a familiar pain: training and serving large models costs too much. It bundles data, model, and pipeline parallelism with heterogeneous training, spreading work across GPUs and host memory to cut the hardware needed per run.

The latest release, v0.5.0, upgrades transformers support and fixes LoRA model loading. The more concrete recent signal is hardware: the project's Llama-style benchmarks show NVIDIA B200 delivering about 50 percent higher throughput than comparable setups on a 7B model across eight cards, and over 70 percent on a 70B model across sixteen.

The maintainers also sell cloud GPU access and model APIs through HPC-AI, so benchmark results come from a vendor with a commercial stake.

The catch: the project has 479 open issues and its release cadence is slowing, so builders should test their own workloads before committing to it in production.

Use Cases
  • ML teams training 7B-70B parameter models across multi-GPU clusters
  • Startups seeking cheaper fine-tuning of open-source foundation models
  • Infrastructure engineers benchmarking B200 versus H200 training throughput

Source: hpcaitech/ColossalAI — based on the README and release notes.

shadcn/ui Patch Stops Bulk Installs From Adding Off-Style Components 🔗

Project's component picker now filters to each project's chosen style, so `shadcn add --all` no longer pulls in mismatched code.

shadcn-ui/ui · TypeScript · ▲ 75 in 1d Est. 2023

The latest `shadcn@4.22.

1release fixes a quiet but real problem for teams using the CLI. Runningshadcn add --all` and the interactive component picker previously offered components that didn't belong to a project's chosen style. Now both respect the style setting.

What changed:

  • shadcn add --all installs only components available for the project's style.
  • The component picker lists only those same components.

The fix is a patch-level change, so it ships without new features or API shifts. For teams generating components into their own codebases, it removes a step of manual cleanup after bulk installs.

The catch: The project carries 1,780 open issues, so teams should check whether their component needs are covered before standardizing on the CLI.

Previously in The Times “covered” — Oct 15

Use Cases
  • Frontend teams bootstrapping a new Next.js app with a consistent component set
  • Design-system engineers building an internal library on Radix or React Aria primitives
  • Solo developers adding Tailwind-styled, accessible UI components to Vite projects quickly

Source: shadcn-ui/ui — based on the README and release notes.

Quick Hits

google-research A large collection of research code and notebooks from Google Research spanning machine learning, language, vision, and beyond, useful for studying cutting-edge techniques. 39k
generative-ai-for-beginners A structured course of 21 lessons walking beginners through building generative AI applications, from core concepts to working prototypes. 121.8k
mediapipe Cross-platform, customizable pipelines for real-time vision, audio, and other ML tasks on live and streaming media, deployable across mobile, web, and desktop. 37.4k
ultralytics A toolkit for training and deploying YOLO models that handles detection, segmentation, classification, pose estimation, and object tracking in one package. 62.7k
ai-agents-for-beginners An 18-lesson beginner course covering how to design and build AI agents, from fundamentals to hands-on implementation. 77.6k

PX4 v1.17 Adds Altitude Cruise and Cleaner ROS 2 Control for Fixed-Wing Drones 🔗

The open-source autopilot stack adds a steady-cruise multicopter mode, keeps fixed-wing takeoffs climbing on navigation loss, and exposes ROS 2 setpoints for planes and rovers.

PX4/PX4-Autopilot · C++ · ▲ 11 in 1d Est. 2012 · Latest: v1.17.0

PX4 v1.17 lands with changes aimed at operators who fly routes rather than hover.

The headline addition is Altitude Cruise, a multicopter mode that holds tilt and heading when the sticks are released. Where Altitude mode brings the vehicle to a stop, Altitude Cruise keeps it moving at a steady velocity.

Fixed-wing operators get two changes. Fixed Wing Takeoff now keeps climbing with level wings if navigation is lost, and it can take the takeoff waypoint's latitude and longitude as the loiter position. Separately, fixed-wing vehicles, including VTOLs in fixed-wing mode, can now be commanded from ROS 2 through a new FwLateralLongitudinalSetpointType interface, which removes the need for custom bridging code in that workflow.

The release also matures the in-tree Zenoh middleware toward rmw_zenoh compatibility, adds Gazebo Jetty support and an Ackermann SIH simulation model, and brings three new INS drivers: MicroStrain, sbgECom and EULER-NAV. Septentrio GNSS resilience reporting and barometer auto-calibration against GNSS height round out the changes.

Built on uORB and licensed under BSD 3-Clause, PX4 is hosted by the Dronecode Foundation under the Linux Foundation. The project carries 482 open issues, and the code is actively committed.

The catch: The repository reports 482 open issues and the stack spans many airframes. Only the multicopter, fixed-wing, VTOL and rover frames are in the regular flight-test program; helicopters, boats and submarines carry only basic support. Verify your airframe against the test program before depending on it.

Previously in The Times “covered” — Oct 20

Use Cases
  • Survey-drone operators needing steady-velocity cruise on multirotors.
  • Fixed-wing teams building ROS 2 autonomy stacks for planes.
  • Rover developers integrating PX4 with Zenoh-based middleware.

Source: PX4/PX4-Autopilot — based on the README and release notes.

More Stories

Text-to-CAD Plugin Lets Coding Agents Generate Manufacturable 3D Parts 🔗

Agents now output STEP, STL and 3MF files, run design-for-manufacturing checks, and send jobs to fabrication services.

earthtojake/text-to-cad · Python · ▲ 270 in 1d 6mo old

The text-to-cad plugin gives coding agents a local workflow for generating 3D models. Agents can write STEP, GLB, STL and 3MF files, run design-for-manufacturing checks, and produce engineering drawings.

It also connects to 3D printing, sheet metal and CNC fabrication services.

The plugin works with Claude Code, Codex, Cursor, Gemini and Grok. It installs through uv, and its cadgen mcp server brings the skills and a viewer. The latest release, v0.7.26, fixes mesh export on machines without Node on PATH, removing a setup dependency for that path.

Telemetry is on by default. It sends usage stats and crash reports under a random ID, and it excludes files, paths and prompts. Users can turn it off with uvx cadgen telemetry off.

The project is about six months old, with 29 open issues and a last commit one day before this report.

The catch: the plugin is only as reliable as the agent driving it, and the open issues, not the release notes, are the place to check whether geometry and fabrication outputs hold up on your parts.

Previously in The Times “covered” — Oct 17

Use Cases
  • Hardware startups generating printable enclosure prototypes from natural-language specifications
  • Robotics engineers producing STEP files for custom brackets and fixtures
  • Makers sending agent-designed parts directly to CNC or sheet metal fabrication services

Source: earthtojake/text-to-cad — based on the README and release notes.

Pinocchio Gives Robot Builders Fast Dynamics and Gradients 🔗

Version 4.1.0 adds URDF v1.2 support, parsing acceleration and jerk limits directly from robot models

stack-of-tasks/pinocchio · C++ · 3.8k stars Est. 2014

Pinocchio, the C++ rigid-body dynamics library from Inria's Willow team, computes the standard algorithms for articulated robots and their analytical derivatives. Those derivatives are what make gradient-based control, trajectory optimization and learning practical on real robot models.

The latest release, v4.1.0, tracks the URDF v1.2 standard. Models can now declare acceleration and jerk limits in the <limit> element, and those limits survive Python pickling after a fix for infinite bounds. Capsule geometry is parsed as a native CAPSULE shape.

Pinocchio is built on Eigen and coal, and ships a Python interface installable through Conda. It underpins Crocoddyl, Aligator and the Humanoid Path Planner.

The catch: the project carries 104 open issues, and its build still needs careful configuration on some compilers and platforms.

Use Cases
  • Robotics researchers computing gradients for trajectory optimization on articulated arms
  • Control engineers loading URDF models with acceleration and jerk limits into Python
  • Humanoid motion-planning teams building on Pinocchio-based solvers like Crocoddyl

Source: stack-of-tasks/pinocchio — based on the README and release notes.

OpenArm Ships Second Release With Fixes for Teleoperation and Hardware 🔗

Release 1.1 adds automated zero-position calibration, standard Realsense camera mounts, and a redesigned 7-DoF elbow control interface.

enactic/openarm · MDX · 3.6k stars Est. 2024

The open-source OpenArm project has shipped its second OpenArm 01 release, targeting the rough edges that early builders hit most often.

Calibration is now automated, replacing a manual zero-position procedure that was prone to human error.

A modular camera base adds official CAD for Realsense D435 chest and D405 wrist mounts, so data-collection rigs no longer need custom designs.

The most consequential change is on the leader side. A redesigned J5 casing and a rubber band interface let the operator guide the elbow directly, resolving ambiguity from redundant joint angles on the 7-DoF arm.

Release 1.1 also sits atop a dora-rs tutorial stack in which each node is a separate repository wired together by dataflow YAML.

The catch: the project carries 18 open issues and its releases are young, so builders should confirm the calibration and elbow behavior on their own hardware before committing to a data pipeline.

Previously in The Times “covered” — Oct 15

Use Cases
  • Robotics labs collecting bimanual teleoperation data for imitation learning.
  • Researchers reproducing contact-rich manipulation benchmarks in standardized OpenArm Cells.
  • Engineers bridging real OpenArm hardware to MuJoCo simulation for reinforcement learning.

Source: enactic/openarm — based on the README and release notes.

Quick Hits

openpilot Upgrades driver-assistance features on over 300 supported cars, turning compatible vehicles into a robotics platform with an open-source operating system. 64k
OpenKAI Provides a modern C++ framework for controlling unmanned vehicles and robots, covering the perception and control pieces developers otherwise build from scratch. 262
ontology-development-kit Manages the full lifecycle of ontologies, from authoring and building through testing and release, using a containerized toolkit for reproducible workflows. 386
crocoddyl Solves robot motion planning and control under contact sequences using efficient Differential Dynamic Programming-style solvers, suited to legged and manipulation tasks. 1.3k
gz-sim Simulates robots in open-source physics environments with sensors and dynamics, letting you test control and perception code before touching hardware. 1.5k

OpenCTI Tightens Threat Intelligence Graphs With Connector and Access-Control Fixes 🔗

Latest release hardens relationship handling and adds a chatbot proxy; the open-source platform still carries 2,216 open issues.

OpenCTI-Platform/opencti · TypeScript · ▲ 4 in 1d Est. 2018 · Latest: 7.261019.0

OpenCTI, the open-source platform for managing cyber threat intelligence, has shipped release 7.261019.

0 with a focus on data integrity. Several fixes target the graph layer where threat data is stored and linked.

Ingestion and deletion paths got the most attention. The backend now rejects ref relation adds when the target cannot be found, and handles ref relationship deletion when the source is already gone. Inferences that have already been deleted no longer flood error logs. Stix elements with an unresolvable type are handled during access checks rather than failing the request.

The UI received fixes for deployed ingestion values and for marking display in public dashboards, where a single marking chip now appears instead of duplicates.

On the enhancement side, the chatbot now proxies decks, reports and videos generated by XTM One into its embedded chat, and documentation images are stored once and shared across doc versions.

The platform is built on the STIX2 schema, exposes a GraphQL API, and connects to tools such as MISP, TheHive and MITRE ATT&CK. Data can be exported as CSV or STIX2 bundles.

The catch: The Signals line shows 2,216 open issues and 1,483 forks, and the release is a point update of incremental fixes rather than a schema change. Builders should check the open backlog against their own ingestion volumes before committing, and weigh the Enterprise Edition's gated features against the Community Edition.

Previously in The Times “covered” — Oct 19

Use Cases
  • SOC analysts mapping threat actor TTPs to MITRE ATT&CK techniques.
  • CTI teams importing and exporting STIX2 bundles between partner platforms.
  • Security engineers integrating MISP and TheHive with a central intelligence graph.

Source: OpenCTI-Platform/opencti — based on the README and release notes.

More Stories

SafeLine Adds Monitor Mode So Builders Can Test Deny Rules Safely 🔗

Latest release also fixes a bundled NGINX vulnerability, CVE-2026-1642, in its tengine component.

chaitin/SafeLine · Go · 22.8k stars Est. 2023

SafeLine, the self-hosted Go web application firewall, now lets operators log deny-rule matches without blocking traffic. Monitor Mode gives teams a way to tune rules against live requests before enforcing them, cutting the risk of blocking legitimate users.

The v9.4.3 release also patches CVE-2026-1642, an NGINX SSL upstream injection flaw in the bundled tengine build. Operators running SafeLine should update.

Other changes include:

  • ACME auto-renewal now reuses the existing private key, keeping the public key fingerprint stable.
  • Downgrades to Personal or Lite plans now disable over-quota applications while retaining their data.
  • Several fixes address Config Auto Sync and node re-binding.

The catch: SafeLine has 48 open issues, and the release notes do not say how the Config Auto Sync and node re-binding fixes were validated across multi-node deployments.

Use Cases
  • Security engineers tuning deny rules without blocking live customer traffic.
  • Self-hosting operators running SafeLine in front of NGINX-based web applications.
  • Small teams downgrading plans who need to keep application configurations intact.

Source: chaitin/SafeLine — based on the README and release notes.

One-Line Installers Now Cover Immich, Zitadel and InvenTree on Proxmox 🔗

Latest release fixes install failures and adds Zitadel's v2 login flow, cutting manual setup for homelab operators.

community-scripts/ProxmoxVE · Shell · ▲ 12 in 1d Est. 2024

The community-scripts project's latest release targets installers that broke on first run. Fixes land for Plane, InvenTree, Silo and Zitadel, while Immich is pinned to version 3.

3.4 to stop drift.

The most notable change is Zitadel, which now supports both its v1 and v2 login. Scripts that previously stalled during setup now run init and setup in the foreground, so the operator sees failures immediately rather than after a silent hang.

Several fixes address packaging. InvenTree moved to a new package source, and its apt steps run under systemd so post-install scripts can finish. Profilarr now passes its Deno pin as the version.

The changes are incremental, but they show the project maintaining its existing catalogue rather than only adding services.

The catch: the project runs on community maintenance, with 14 open issues, and each script depends on upstream packaging that can change without notice.

Previously in The Times “covered” — Oct 17

Use Cases
  • Homelab operators deploying Zitadel identity provider on Proxmox containers
  • Self-hosters installing Immich photo servers with a pinned, tested version
  • Small teams standing up InvenTree inventory systems without manual packaging

Source: community-scripts/ProxmoxVE — based on the README and release notes.

NGINX Ships Patch Batch Fixing Five Security Holes in One Release 🔗

Mainline 1.31.7 also adds native GeoIP2 support and HTTP/2 priority and QUIC improvements.

nginx/nginx · C · 31.9k stars Est. 2015

The latest mainline release, **nginx-1.31.

7**, closes five vulnerabilities, and operators running it should prioritize the upgrade.

The fixes cover:

  • A buffer overflow when alias is combined with rewrite (CVE-2026-15176)
  • A buffer overflow when evaluating string expressions with variables (CVE-2026-93479)
  • A request body injection flaw in HTTP/3 (CVE-2026-95101)
  • A session forgery flaw in TLS session ticket key rotation (CVE-2026-97629)
  • A use-after-free in ngx_http_ssi_module under AIO (CVE-2026-97205)

Beyond the patches, the release adds native GeoIP2 support, HTTP/2 priority handling and QUIC improvements. Builders who install from distribution packages may lag behind; the project advises using official packages or sources from this repository.

The catch: Five CVEs in a single mainline cycle is a reminder that the feature-rich codebase keeps widening its attack surface, so teams should track advisories rather than assume a version is safe.

Previously in The Times “covered” — Oct 15

Use Cases
  • Web operators patching alias and rewrite configurations against buffer overflows
  • Platform teams running HTTP/3 edges that need the request injection fix
  • Engineers using TLS session tickets who must rotate keys on patched builds

Source: nginx/nginx — based on the README and release notes.

Quick Hits

subfinder Discovers subdomains passively and quickly, pulling from public sources so you can map an organization's attack surface without touching the target. 14.6k
httpx Probes large lists of hosts over HTTP in bulk, reporting status codes, titles, tech stacks, and more through a single fast, scriptable toolkit. 10.5k
bunkerweb Shields web applications from common attacks as a containerized, cloud-native firewall that can be deployed without rewriting your application code. 11.1k
trivy Scans containers, Kubernetes clusters, code repos, and cloud accounts for vulnerabilities, misconfigurations, leaked secrets, and SBOM generation in one tool. 38.6k
authelia Adds centralized single sign-on and multi-factor authentication in front of your web apps, with OpenID certification and post-quantum-ready cryptography. 29.4k

Bun 1.4.3 Ships Node-Compatible Runtime, Bundler, and Package Manager in One Binary 🔗

Rust-built toolkit replaces separate runtime, bundler, test runner, and npm client, with Linux kernel 5.1+ and CPU-dependent x64 builds.

oven-sh/bun · Rust · ▲ 18 in 1d Est. 2021 · Latest: bun-v1.4.3

Bun's latest release, **v1.4.

3**, continues the project's push to collapse the JavaScript toolchain into one executable called bun. The release is a point update rather than a rewrite, shipping as a drop-in replacement for Node.js in existing projects with little to no code changes.

The architecture is the key differentiator. Written in Rust and built on JavaScriptCore, the runtime targets faster startup and lower memory use than Node.js. The same binary handles script running, testing, bundling, and package management. The project's own pitch is that a development environment can be reduced to bun alone instead of a large node_modules tree.

Installation is a single command on macOS and Linux (curl -fsSL https://bun.sh/install | bash) or PowerShell on Windows. Upgrades run through bun upgrade. The project publishes a canary build on every commit to main for teams that want earlier access.

Platform coverage spans Linux (x64 and arm64), macOS (x64 and Apple Silicon), and Windows (x64 and arm64). Linux users are advised to run kernel 5.6 or later, with 5.1 as the floor.

The catch: The project carries 9,125 open issues, a sign of how much surface area a runtime that aims to replace Node.js must cover. x64 users may hit "illegal instruction" errors on older CPUs, and compatibility with every Node.js edge case should be verified against your own dependency tree before migrating production workloads.

Previously in The Times “covered” — Oct 17

Use Cases
  • Teams replacing Node.js runtime and npm client in existing projects
  • Developers consolidating bundling and testing into a single toolchain
  • CI pipelines seeking faster install and test cycles on Linux or macOS

Source: oven-sh/bun — based on the README and release notes.

More Stories

Deno 2.9.7 Tightens Security Checks Across Node Compatibility Layer 🔗

Patch release fixes permission gaps in networking, DNS and multicast, and corrects shell completions for the Rust-built runtime.

denoland/deno · Rust · 108.7k stars Est. 2018

Deno, the JavaScript, TypeScript and WebAssembly runtime built on V8, Rust and Tokio, shipped version 2.9.

7 this month. The release focuses on security and compatibility rather than new features.

Several fixes close permission gaps:

  • Network checks: tcp_wrap bind now validates resolved IPs against the net deny list.
  • Multicast: membership changes now require permission checks.
  • Lockfiles: tarball registry paths are validated during install.

Compatibility work targets node: modules, including DNS error codes and AsyncLocalStorage context. CLI fixes restore bash and zsh completions and deno bundle --sourcemap behavior.

Deno's node: shim layer is where compatibility bugs cluster, and this release patches several of them.

The catch: the project carries 1,636 open issues, and this release is a patch series, so builders should weigh the remaining compatibility surface before migrating production Node code.

Use Cases
  • Backend engineers replacing Node servers with secure-by-default TypeScript runtimes
  • Platform teams auditing permission-gated networking in multi-tenant JavaScript services
  • Developers porting Node packages that depend on DNS and child-process behavior

Source: denoland/deno — based on the README and release notes.

Lightpanda Browser Ships 1.0.1 With Broader Web API Coverage for Agents 🔗

Written from scratch in Zig, the headless browser claims 9x Chromium's speed on 933 real pages

lightpanda-io/browser · Zig · ▲ 44 in 1d Est. 2023

Lightpanda is a headless browser built from scratch in Zig for AI agents and automation. It is not a Chromium fork, and the project claims roughly 16x less memory and 9x faster than Chromium on a benchmark of 933 real pages fetched over the network on an AWS EC2 m5.

large instance.

The latest release, 1.0.1, expands what automation scripts can rely on:

  • New Web APIs: Web Locks, Compression Streams, RSA-OAEP in Web Crypto, and ElementInternals for custom elements.
  • Forms: implicit submit on Enter, and change events fired on blur.
  • Breaking changes: setImmediate and clearImmediate were removed, and javascript: URLs now execute instead of navigating.

It speaks the Chrome DevTools Protocol, so Puppeteer and Playwright can drive it, and it can dump pages as markdown, PNG or PDF. Official Docker images and nightly binaries cover Linux and macOS.

The catch: the project is young, with 105 open issues, Linux binaries that require glibc (so Alpine and Android are out), and no native Windows build, so Windows users must run it under WSL2.

Use Cases
  • Agent developers scraping pages without paying Chromium's memory footprint
  • QA teams running Playwright suites against a lighter headless backend
  • Data pipelines converting web pages into markdown for LLM ingestion

Source: lightpanda-io/browser — based on the README and release notes.

Go Language Team Keeps Shipping Toolchain Updates Across Platforms 🔗

Repository with more than 22,000 forks remains the upstream source for official binary releases

golang/go · Go · 139.4k stars Est. 2014

The Go project's canonical repository is still moving daily. The most recent commit landed one day before this snapshot, with updates pushed to the main branch that feed the official toolchain.

The language is designed for simple, reliable, and efficient software. Its compiler, standard library, and runtime live in this single repository, distributed under a BSD-style license.

Key points for builders:

  • Official binaries are published at go.dev/dl, with source-build instructions for unsupported platforms.
  • Canonical development happens on go.googlesource.com; GitHub hosts a mirror.
  • Bug reports and proposals go to the issue tracker; questions are routed elsewhere.

With roughly 10,400 open issues, the backlog is large. Triage speed and proposal acceptance are the questions to ask before depending on any single change.

The catch: the issue tracker is reserved for bugs and proposals, so support questions must go elsewhere, and the backlog signals that not every reported problem will be resolved quickly.

Use Cases
  • Platform engineers building cross-compiled network services for Linux and Windows
  • Infrastructure teams writing CLI tools that ship as single static binaries
  • Contributors patching the standard library or compiler via the public review process

Source: golang/go — based on the project README.

Quick Hits

fzf Interactively filter any list from the terminal by typing a few characters, with fuzzy matching that ranks the best results first and plugs into your shell history and editor. 83.7k
PowerToys Windows power-user toolkit adding features like a window layout manager, keyboard remapping, quick launcher, color picker, and file explorer previews. 139.5k
obs-studio Record your screen or stream live to Twitch, YouTube, and other platforms, with scene composition, multiple sources, and plugin support, all free. 77.9k
json Work with JSON in C++ as naturally as native containers, using intuitive syntax for parsing, building, serializing, and converting to and from STL types. 50.8k
clash-verge-rev Run a cross-platform desktop proxy client built on Tauri and Rust, giving you a polished GUI for managing rules, profiles, and traffic routing. 152.9k

OpenIPC Firmware Extends Open Camera Software Beyond HiSilicon Chips 🔗

Nightly build ef421c8 adds a growing list of SoC families, letting builders replace vendor camera firmware on more hardware.

OpenIPC/firmware · C · 2.3k stars Est. 2021 · Latest: nightly

OpenIPC's firmware, written in C, is an alternative to the vendor software shipped on cheap IP cameras. The project began with HiSilicon processors only.

It now targets chips from Ambarella, Anyka, Fullhan, Goke, GrainMedia, Ingenic, MStar, Novatek, SigmaStar and XiongMai, and the README says the list will keep growing.

The latest nightly, built October 20 from commit ef421c8, is the newest artifact in the repository. The release notes list a web UI image and a commit hash, which gives builders a fixed reference for reproducible flashing. The project is built on buildroot and u-boot, so a build can be traced from bootloader to userspace.

The project also runs a two-tier support model. Community help is available through chat. Businesses can buy commercial support, which the maintainers say funds full-time development and prioritizes bug reports and feature requests from paying customers.

Contributors are asked to read CLAUDE.md (also AGENTS.md) before sending a first patch. That file describes the repository layout and which changes belong where.

The catch: The project has 164 open issues and a fast-moving nightly channel, not a tagged stable release. Support quality on any single chip family will vary. Check your exact SoC and sensor against the wiki before committing hardware to a deployment.

Previously in The Times “covered” — Oct 20

Use Cases
  • Hobbyists flashing open firmware onto low-cost HiSilicon-based cameras
  • FPV builders using OpenIPC on airborne and ground video links
  • Integrators deploying replacement firmware across mixed-chip camera fleets

Source: OpenIPC/firmware — based on the README and release notes.

More Stories

Course Repo Teaches Builders to Script Polymarket Trades 🔗

Repository pairs a trading-bot curriculum with code for the prediction-market platform, with one fork so far

Nour-Br/polymarket-trading-bot-course · Unknown · 171 stars 2w old

The Nour-Br/polymarket-trading-bot-course repository packages a course on building automated trading bots for Polymarket, the prediction-market platform where users buy and sell shares tied to real-world outcomes.

The project was created on 5 October 2026 and last pushed on 20 October.

It has no open issues and one fork, and its last commit landed one day before this report.

Its README is absent, and its description is a repeated keyword string, so the course's structure, code samples and setup steps cannot be confirmed from the repository alone. The language is listed as unknown.

For builders, the appeal is a worked example of how prediction-market bots interact with a live order book. Anyone adopting it should check the code before trusting it with funds.

The catch: The repository has no README, no stated language and almost no documentation, so there is no evidence yet that the course works as advertised.

Use Cases
  • Developers learning to script automated orders against Polymarket's API
  • Quant-curious traders testing prediction-market strategies before committing capital
  • Instructors seeking a reference repository for teaching algorithmic trading

Source: Nour-Br/polymarket-trading-bot-course — based on the project README.

DIY Radar Launch Monitor Brings Golf Shot Data to Builders 🔗

OpenFlight pairs a $300-class Doppler radar with optional angle sensing for roughly $819 total

open-flight/openflight · Python · ▲ 3 in 1d 10mo old

OpenFlight is an open-source golf launch monitor built on the OPS243-A Doppler radar. It measures ball speed in the 15-200 mph range at ±0.

5% accuracy, detects club speed from pre-impact readings, and computes smash factor and estimated carry.

Adding a TI IWR6843 angle radar unlocks measured launch angle and an experimental club path estimate. The project has dropped support for new builds using K-LD7 angle radars, which are now deprecated. The IWR6843 requires custom firmware, but a validated prebuilt image ships in firmware/releases/, so builders can flash it without the TI toolchain.

Battery operation via a Geekworm UPS HAT and a sound trigger wired to the SEN-14262 round out the hardware path. Spin rate remains experimental and is not used for carry by default.

The catch: With 36 open issues and a project still labeled in active development, builders should expect changing interfaces and rough edges.

Previously in The Times “covered” — Oct 15

Use Cases
  • Home golfers building a low-cost indoor launch monitor for practice sessions
  • Hardware hackers integrating Doppler radar with embedded Python sensing projects
  • Golf coaches prototyping swing-analysis tools without commercial launch-monitor pricing

Source: open-flight/openflight — based on the project README.

Python Tool Turns Silhouette Cutters Into Custom Card Printers 🔗

v3.0.0 adds borderless 3x3 layouts and plugins for Lorcana, Keyforge, and two LCG games.

Alan-Cha/silhouette-card-maker · Python · 224 stars Est. 2025

Hobbyists who want custom card games or playtest proxies no longer need a craft knife or paper guillotine. The silhouette-card-maker project lays out card images as printable PDFs and pairs them with cutting templates for Silhouette Studio, so a cutting machine handles the trimming.

The latest release, v3.0.0, adds:

  • Borderless templates for 3x3 layouts on letter and a4 paper with standard cards.
  • Extended bleed and corner options, via --extend_corners and --extend_bleed.
  • New plugins for Arkham Horror LCG, Lord of the Rings LCG, and Keyforge, plus Lorcana special variant artwork.

Output is restricted to casual play and playtesting, and proxies must be clearly identifiable as such. Sanctioned tournament use is off-limits.

The catch: The project has 75 open issues and its card-image acquisition depends on third-party plugins that must track changing game sites.

Use Cases
  • Game designers prototyping custom card games without hand-cutting stock
  • TCG players producing clearly marked proxies to playtest decks cheaply
  • Hobbyists using Silhouette machines to batch-print K-pop photocards

Source: Alan-Cha/silhouette-card-maker — based on the README and release notes.

Quick Hits

Eurorack Open-source schematics and PCB designs for a personal collection of Eurorack synthesizer modules, useful for builders wanting to fabricate or study them. 145
librealsense Official Intel RealSense SDK providing C++ APIs and tools to capture, process, and align depth and color data from RealSense cameras across platforms. 9.1k
ibex A small, well-verified 32-bit RISC-V CPU core in SystemVerilog, suited to embedded and FPGA/ASIC designs needing a trustworthy open processor. 2.1k
blinker-library An IoT library for Arduino R4 and ESP32 that connects embedded hardware to cloud dashboards and mobile apps with minimal code. 5.2k
pgtune A browser-based tool that generates tuned PostgreSQL configuration values based on your server's hardware specs, saving hours of manual tweaking. 2.8k

LYGIA Adds WESL and C++ Bundling, Shipping Shaders Across Eleven Targets 🔗

Latest release extends a granular shader library to WGSL-era tooling and native C++ builds, with its dependency-resolution model unchanged.

patriciogonzalezvivo/lygia · GLSL · ▲ 2 in 1d Est. 2021 · Latest: 1.4.1

LYGIA, the GLSL shader library that began life in 2021, has shipped version 1.4.

  1. The release matters to graphics teams building for more than one platform. It moves the library further toward a single, reusable function set across shading languages.

The patch adds a wesl entry to the language dictionary, a sign that the library is tracking the WESL shading language alongside wgsl and hlsl. It also introduces a C++ bundle script and a CMake routine, letting native projects pull LYGIA functions without a web toolchain. A new native test runner and expanded WGSL test coverage round out the changes.

The core design is unchanged. Functions are granular and pulled in with #include directives, and a project can either clone the library locally or resolve dependencies through the hosted server at lygia.xyz. For size-conscious teams, a prune.py script strips the library down to a single language. An npm bundle and plugins for Vite, esbuild and webpack cover web builds.

The repository shows 26 open issues and 225 forks, and the last commit landed recently, so maintenance is active.

The catch: Adopting LYGIA means accepting its include-based resolution model. Teams that need a locked, auditable dependency graph should test how #include paths behave in their own build before committing, and confirm that the WESL and C++ paths are production-ready rather than newly added.

Use Cases
  • Graphics engineers porting one shader across GLSL, HLSL, and WGSL targets.
  • Web developers bundling GLSL helpers into Vite or webpack projects.
  • Native C++ teams adding shader utilities through a CMake build.

Source: patriciogonzalezvivo/lygia — based on the README and release notes.

More Stories

SpacetimeDB Lets Clients Talk Straight to the Database 🔗

Release v2.12.0 adds typed environment variables and automatic reconnect for TypeScript and C# clients

clockworklabs/SpacetimeDB · Rust · ▲ 3 in 1d Est. 2023

SpacetimeDB merges a relational database and an application server into one process. Developers upload logic written in Rust, C#, TypeScript, or C++ as a module, and clients connect to the database directly.

State changes sync to connected clients in real time.

The latest release, v2.12.0, targets two gaps builders hit in production.

Configuration and secrets. Modules can now declare typed environment variables. Values are validated against those declarations and updated atomically with a publish. Stored values persist across publishes by default, and spacetime env get lets authorized users inspect them.

Resilient clients. The TypeScript and C# SDKs can now survive dropped connections. Opting in with withAutomaticReconnect() or WithAutomaticReconnect() enables exponential backoff, subscription replay, and cache reconciliation.

State lives in memory, with a commit log on disk for durability. The project is backed by a live MMORPG, BitCraft Online, running its entire backend on the platform.

The catch: the project carries 940 open issues and is still pre-1.0 in its release cadence, so teams should test its behavior under their own load before committing a core system to it.

Previously in The Times “covered” — Oct 15

Use Cases
  • Game studios running multiplayer backends without managing separate game servers
  • Small web teams building collaborative apps as a single-language deployment
  • Developers replacing caching layers and webservers with one real-time database

Source: clockworklabs/SpacetimeDB — based on the README and release notes.

One Rendering Library Now Spans Eight Graphics APIs and Two Dozen Languages 🔗

bgfx lets engines target Vulkan, Metal, Direct3D and WebGPU from one C++ codebase, with bindings for Rust, Zig and Swift.

bkaradzic/bgfx · C++ · ▲ 3 in 1d Est. 2012

bgfx, the cross-platform rendering library maintained by Branimir Karadžić, is a "bring your own engine" layer: it handles draw submission across graphics backends so game and tool developers don't have to.

The most recent work extends its reach on both axes.

Its supported backends include Direct3D 11 and 12, Metal, OpenGL 4.3+, OpenGL ES 3.0+, Vulkan, WebGL 2.0 and WebGPU through Dawn. Platforms run from Android 4.0 and iOS 16 to Linux, macOS 13, Windows 7 and Wasm. Community bindings now cover Rust, Zig, Swift, Go, Python, C# and others.

  • Who uses it: Indie studios and engine authors, including the Crown engine and the AirMech RTS.
  • Scope: Rendering only; you still build the rest of your engine.

The catch: With 67 open issues and a codebase that is more than a decade old, builders should check recent activity against their target platforms before committing, and confirm the bindings they need are maintained.

Use Cases
  • Indie studio shipping one game across mobile, desktop and consoles
  • Engine author adding multi-backend rendering without writing a renderer
  • Tool developer building cross-platform visualization in Rust or Zig

Source: bkaradzic/bgfx — based on the project README.

Quick Hits

OpenRA Recreates classic Westwood real-time strategy games like Red Alert in C#, running natively on Windows, Linux, BSD, and macOS. 17.6k
godot A full-featured 2D and 3D engine with a built-in editor that exports to desktop, mobile, web, and console targets. 118.8k
GDevelop A cross-platform engine for building 2D, 3D, and multiplayer games with visual tools that make development approachable for beginners. 27.8k
Slay-The-Robot Provides a ready-made Godot framework with the core systems needed to build roguelike deckbuilder games. 292
godot-road-generator Generates 3D highways and streets in Godot, with lane-following traffic for driving simulations and open-world scenes. 1.2k
pyxel A minimal retro game engine for Python that handles graphics, sound, and input with a classic fixed-palette aesthetic. 18.4k
The Git Times AI Desk
Ask about today's stories — or hit “Ask about this” on any article to focus on one.

Unlock the Git Times AI desk to ask about today's stories and the AI model market.

Upgrade to Premium
Answers by the Git Times AI desk · verify before you ship