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 →

Local Mac Server Lets Developers Run Open Models Without Python or Cloud 🔗

One Zig-built server speaks OpenAI, Anthropic and Ollama APIs, adding image, video, music and speech generation on Apple Silicon.

ddalcu/mlx-serve · Zig · ▲ 18 in 1d 8mo old · Latest: v26.10.2

mlx-serve lets developers run open-weight models entirely on an Apple Silicon Mac, with no Python runtime, no account and no network dependency. The server listens on localhost:11234 and answers requests written for the OpenAI, Anthropic and Ollama APIs, so existing clients can be pointed at it without code changes.

The backend is written in Zig, with a Swift macOS app layered on top for chat and generation. The project's own release notes highlight the scope beyond text:

  • Coding agents: mlx-serve launch claude starts Claude Code against a local model, configured to the model's real context window.
  • Media generation: image, video, music and speech models, including FLUX.2 and Qwen3-TTS with voice cloning, run in the app or over HTTP.
  • Large models: the README says some mixture-of-experts models larger than system memory can run on a 128 GB Mac by streaming experts from SSD, and two Macs linked by Thunderbolt 5 can share one model.

For builders, the appeal is a single local endpoint that replaces a cloud API for development, private transcription and offline assistants, under an MIT license. The project also ships Linux builds for NVIDIA GPUs and an iPhone build.

The catch: The project is roughly eight months old and carries 67 open issues, and its quality on media-generation models is not independently benchmarked here. It requires macOS 26.2 on Apple Silicon, so it is no help to Intel or Windows developers, and anyone adopting it for production should verify how the SSD-streaming path performs on their own hardware before relying on it.

Why this leads today It offers developers a new way to run local models on their own Macs, plugging into existing OpenAI and Anthropic tooling without Python, while today's other contenders are niche or long established.

Use Cases
  • Mac developers running Claude Code or Codex against a local model offline.
  • Teams keeping transcription and meeting notes on-device for privacy reasons.
  • App builders swapping a cloud LLM endpoint for a local OpenAI-compatible server.

Source: ddalcu/mlx-serve — based on the README and release notes.

More on the Front Page

Reason Network Lets Teammates' Coding Agents Message Each Other Directly 🔗

One Rust daemon per machine, no server, and it works across ten agent tools including Claude Code and Cursor.

reason-machines/reason-network · Rust · 527 stars 3d old

A new open-source project lets coding agents on different developers' machines find each other and exchange messages without a central server. The engine behind reason network runs as one small daemon per computer and connects peers directly.

Every active agent session on a teammate's machine appears in a shared roster. Each entry shows who is running it, which repo and branch it is on, whether it is busy or idle, and what it is doing now. Any agent can message the right peer, or send up to 10 text files of 256 KB each, 512 KB total.

Agents get three tools: list_team, send_message and ask_user, plus check_inbox where push delivery is unavailable. Delivery depends on the host. Claude Code, Codex, opencode, pi and Reason receive messages mid-session and wake idle sessions. Cursor, Gemini, Copilot and Grok receive them at their next step. Hosted assistants connect through an MCP endpoint.

Version 0.11.1 is a small patch. It changes how a removed machine handles a replacement invite link, and moves joining to Reason browser sign-in.

The catch: The project is young. It has a single tagged release line, two open issues, and an install path that depends on Reason's hosted sign-in and an invite-link flow. Builders should test peer discovery and message delivery on their own network before relying on it for team workflows.

Use Cases
  • Engineering teams sharing live coding-agent status across developer laptops
  • Developers having one agent request help or files from a teammate's agent
  • Multi-tool teams coordinating Claude Code, Cursor and Codex sessions together

Source: reason-machines/reason-network — based on the README and release notes.

Claude Code Strips Ads From Old Android TVs in Minutes 🔗

A prompt-driven cleanup disables bloatware and sponsored rows, leaving apps, HDMI inputs and a clock.

Ansub/tv-detox · Java · 758 stars 2d old

A new GitHub project lets an AI coding agent do the tedious work of rescuing sluggish Android TVs. Users paste a prompt into Claude Code or Codex on a laptop on the same Wi-Fi network, then press OK on the remote.

The agent turns off bundled apps and sponsored home-screen rows through adb, leaving a minimal screen with your apps, HDMI inputs and a clock. Nothing is deleted. Every change can be reversed, and the agent asks before each one.

Google TV and Chromecast users need care. Version 1.4.1 keeps the device's own home screen running by default, after some units got stuck restarting and needed a factory reset. Newer models require Wireless debugging with a pairing code.

The catch: the project has 13 open issues and is a single-maintainer tool with no guarantee of support, so back up your settings before you run it.

Use Cases
  • Households with aging Android TVs wanting ad-free home screens without technical work.
  • Hotel or office staff tidying shared TVs of identical models.
  • Developers adapting the prompt to clean up other low-power Android devices.

Source: Ansub/tv-detox — based on the README and release notes.

Open-Source Rust CAD Lets Builders Rebuild Models From a Single Dimension 🔗

SolidCraft runs on desktop and in the browser, and AI agents can model through its built-in MCP server.

tangency-labs/solidcraft · Rust · 7.9k stars 1w old

SolidCraft is an open-source parametric 3D CAD application written entirely in Rust. Users sketch, constrain and extrude solids along a feature timeline, then change one dimension and watch the model rebuild.

The project ships as a desktop app for Windows, macOS and Linux, and as a web app that needs no install. A built-in MCP server lets AI agents drive modeling directly.

The project's own demo builds a Raspberry Pi 4 case from an empty document, with mounting standoffs, vents, engraved text and a material definition, then changes the height and regenerates the part.

The team reports that 75 of 76 public reference parts match analytic or FreeCAD-computed volume, area, centre of mass and bounding box. The latest release, v0.16.2, is a navigation fix.

The catch: the project is early, with 1,565 open issues, and its downloads are not yet code-signed, so builders must bypass SmartScreen or Gatekeeper warnings on first run.

Use Cases
  • Hobbyists designing enclosures and brackets for 3D-printed electronics projects
  • Engineers prototyping simple parametric parts in a browser without installing software
  • Developers automating CAD workflows where AI agents generate and revise models

Source: tangency-labs/solidcraft — based on the README and release notes.

Orca Lets Builders Run Five Coding Agents Side by Side 🔗

Each agent gets its own git worktree, and results can be compared or merged from desktop or phone.

stablyai/orca · TypeScript · 99.1k stars 7mo old

Orca is an orchestrator for coding agents. Developers can run Codex, Claude Code, OpenCode or Pi in parallel, each in an isolated git worktree, then compare outputs and merge the winner.

The latest release, v1.4.232, shifts focus to permissions and remote work:

  • Auto permissions: Settings now offer Manual, Auto and Yolo modes. Auto lets supported Claude and Codex agents handle their own approvals.
  • Phone control: Orca Monitor sends notifications when an agent finishes and accepts follow-up prompts from anywhere.
  • SSH recovery: Managed servers reconnect after lost pairing, and tunnels follow a restarted server's port.

Orca also tracks Claude and Codex usage and rate-limit resets, and it can hot-swap accounts.

The catch: The project shows 8,576 open issues, and the Auto permission mode hands approvals to agents, so teams should test it on non-critical repositories first.

Use Cases
  • Solo developers comparing outputs from several coding agents on one task.
  • Engineers steering long-running agent jobs on remote servers from their phones.
  • Teams reviewing agent-generated diffs and sending line comments back before committing.

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

Open-Source Script Strips Ads and Tracking From Fire TV Sticks 🔗

Tool works over ADB without root, touches nothing in system partitions, and reverses in one script.

humblemuzzu/dumbtv · JavaScript · 785 stars 1d old

A GitHub project called dumbtv applies a simple rule to Fire TV sets: keep the apps you chose and the HDMI inputs you use, and drop the rest. It runs from another machine over adb, needs no root, and writes nothing to /system.

The project ships a replacement home screen, dumbtv-home.apk, at 45 KB with no internet permission and no advertising ID. Fire OS 7 and 8 need no permissions at all. A separate catalog tracks which models work and which dialogs block automation.

Tested so far on Fire OS 7.7.1.7 (Android 9) and Fire OS 6 for older sticks. Android TV needs a different package list and launcher approach. The tool does not replace the operating system, unlock a bootloader, or survive a factory reset.

The catch: the repo has 28 open issues and per-model coverage depends on volunteers filing device reports, so untested sets may not work.

Use Cases
  • Households wanting Fire TV without built-in ads or viewing tracking
  • Tinkerers scripting reversible ADB changes across multiple Fire TV devices
  • Contributors documenting per-model Fire TV quirks for a shared device catalog

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

OpenList Forks AList to Keep Cloud Storage Governance Community-Owned 🔗

Latest release adds 500 GB uploads on China Mobile's 139 cloud and md5-based instant uploads on Guangya Pan

OpenListTeam/OpenList · Go · 25.1k stars Est. 2025

OpenList is a Go fork of the AList file-listing server, built by an independent team to keep governance in community hands rather than a single maintainer. It unifies access to multiple cloud drives, including Aliyundrive, OneDrive and local storage, behind one interface.

The newest release, v4.2.7, focuses on driver work:

  • drivers/139 now uploads files up to 500 GB and lets users choose the API client type.
  • drivers/guangyapan adds md5-based instant upload.
  • drivers/pikpak re-logs in automatically when tokens expire.
  • server/s3 gains multipart upload.

The project's license is AGPL-3.0, and it has explicitly disavowed look-alike commercial forks that use its name.

The catch: the project has 302 open issues, and driver support depends on third-party cloud APIs that can change without notice.

Use Cases
  • Self-hosters consolidating several personal cloud drives behind one browsable interface
  • Teams needing large-file transfers to Chinese cloud storage through a single open-source gateway
  • Developers auditing or extending a storage aggregator under the AGPL license terms

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

Free My TV Strips Ads From Google TV Home Screen 🔗

Open-source launcher built with Claude Code cuts home-screen memory by 60 percent and offers one-button rollback

simbasjungles/free-my-tv · Java · 942 stars 0d old

A new open-source project replaces the advertising-heavy Google TV home screen with a launcher that shows no sponsored rows, banners or autoplaying promos.

The home screen surfaces the streaming apps you already have, on a glass shelf you arrange on the TV itself.

Three trending picks refresh hourly, drawn only from installed apps. Weather, hourly forecasts, sunrise times and crypto prices sit one press away.

The app is written in Java and was built with Claude Code. Its README reports 60 fps rendering and 96 MB of memory use, down from 242 MB, measured on a 98-inch TCL set running Android 14.

Setup needs developer mode, USB debugging and a computer on the same Wi-Fi. The project says nothing is uninstalled and no root is required, and one button restores the factory home screen.

The catch: The project is days old with six open issues and no release history, and its performance figures come from a single TV model.

Use Cases
  • Households wanting a streaming home screen without sponsored content or promotional banners
  • Android TV owners seeking a lighter launcher that reduces memory pressure on older hardware
  • Developers studying a Java TV launcher built with an AI coding assistant

Source: simbasjungles/free-my-tv — based on the project README.

Open Source Is Building the Control Layer Around Coding Agents 🔗

A cluster of new repos shifts focus from models to harnesses, review surfaces, remote control, and ad-free tooling for agent workflows

Trendllm-tools
Caho1/open-claude-uialchaincyf/huashu-motionsimbasjungles/free-my-tvAnsub/tv-detoxkitlangton/scrawlshowheyohtaki/motion-promptbacknotprop/plannotatoragent-of-empires/agent-of-empiresstablyai/orcaEverMind-AI/Ravenpipeshub-ai/pipeshub-aiagentconnect-md/agentconnectAI4Finance-Foundation/FinRLAOrbitron/Eridanusddalcu/mlx-serveakdeb/ElatoAINexting-ai/nexting

A new cluster of open-source projects suggests the center of gravity is moving away from models and toward the harness: the software that schedules, observes, and corrects agents doing real work.

Several repos are building the review loop.

plannotator lets developers annotate agent plans and diffs visually and send feedback back to the agent in one click. scrawl lets you mark up a screenshot, record a problem, and hand it to an agent. Both treat human correction as a first-class interface rather than an afterthought.

Others focus on multi-agent orchestration. agent-of-empires manages several Claude Code and OpenCode sessions from a TUI or web UI, while orca and nexting add mobile and remote control. pipeshub-ai goes further, exposing company knowledge through permission-aware search that agents can grep and cite via MCP.

A quieter branch targets hardware. tv-detox and free-my-tv use coding agents to rebuild ad-free Android TV home screens, and mlx-serve runs OpenAI- and Anthropic-compatible inference natively on Apple Silicon.

What ties these together is that the artifacts are increasingly generated by agents and then governed by humans through lightweight tooling.

The catch: Most of these projects are weeks old, lean on proprietary APIs and subscriptions, and lack shared standards for permissions, state, or evaluation. "Harness" is still a loose term, and the review-and-correct loop has not been shown to scale beyond solo developers.

Use Cases
  • Solo developers reviewing agent-generated plans and diffs before merging changes
  • Engineering teams giving agents permission-aware access to internal company knowledge
  • Hobbyists using coding agents to rebuild ad-free home screens on old TVs

Open Source Is Shipping Web Frameworks Everywhere, From CAD to Robot Modeling 🔗

A cluster of new projects shows the browser and Tauri-style desktop shells becoming the default front end for specialized engineering and AI tooling.

Trendweb-frameworks
Caho1/open-claude-uitangency-labs/solidcraftprayag17/Blinkagent-of-empires/agent-of-empiresDolibarr/dolibarrNaiboWang/EasySpiderOpenLegged/URDF-StudioAOrbitron/Eridanuscurl/curljstrieb/github-statsddalcu/mlx-serveOrama-Interactive/Pixelorama

A pattern is emerging across this cluster: specialized, domain-heavy tools are being rebuilt on modern web-frameworks rather than native toolkits. The shift is less about aesthetics than about shipping one codebase to desktop, browser, and automation surfaces at once.

Consider what these projects just delivered:

  • Blink pairs Tauri with React to deliver a desktop Jellyfin client, wrapping a web UI in a native shell.
  • URDF-Studio runs a 3D robot modeler in the browser, with MuJoCo export and AI assistance layered onto the workspace.
  • SolidCraft takes the opposite route: a parametric CAD engine written in pure Rust, exposed through desktop, web, and MCP automation.
  • open-claude-ui reverse-engineers the Claude desktop interface into 30 React components with a detailed interaction analysis.
  • agent-of-empires manages multiple coding agents from either a terminal UI or a web view, explicitly targeting phone access.

The common thread is the interface layer. Engines are increasingly written in systems languages, while the surface is a web or web-derived component tree. Protocols like MCP and OpenAI-compatible APIs let the same backend serve humans and agents. The web stack has become the universal presentation layer for tools that were once native-only.

The catch: This is early and uneven. Wrapping web UIs in desktop shells often trades performance and native integration for velocity, and several repos here are young, single-maintainer efforts. Calling it a settled framework trend overstates what a small sample shows.

Use Cases
  • Robotics engineers previewing and exporting URDF robot models in a browser.
  • Developers orchestrating several coding agents from a phone-accessible web dashboard.
  • Hobbyist media users running a native desktop Jellyfin client built on Tauri.

Open Source Data Infrastructure Shifts Toward Agent-Ready, Structured Pipelines 🔗

Projects now bundle collection, curated datasets, and model catalogs into single self-hostable stacks built for LLM agents.

Trenddata-infra
xiaoyang111222/cn-math-taxonomyLizardByte/Sunshineanomalyco/models.devopenbq-org/OpenBBstefan-jansen/machine-learning-for-tradingNaiboWang/EasySpidercurl/curl

A cluster of recently active repositories points to a clear shift: open source data tooling is being rebuilt around machine consumers, not just human analysts. OpenBB now positions its platform explicitly for "analysts, quants and AI agents," exposing financial data through a single Python interface that agents can call directly.

models.dev tracks AI model metadata in a structured TypeScript-backed database, giving tooling a machine-readable source of truth for pricing and capabilities. Meanwhile, EasySpider pairs visual, no-code scraping with a service-wrapper concept that turns sites into callable endpoints, and curl continues shipping protocol breadth that feeds these pipelines.

The most telling entry is cn-math-taxonomy, which encodes 674 knowledge points and 2,843 problems as a graph with adaptive diagnostics. That is structured domain data designed for reasoning systems, not static reference material. Across the cluster, the common thread is:

  • Schema-first datasets with explicit relationships between entities
  • Unified access layers wrapping heterogeneous sources
  • Self-hosted control over collection and execution, including Sunshine-style local-first streaming

The catch: Most of this is early. Agent-facing interfaces are changing weekly, schemas rarely agree across projects, and data licensing around scraping and financial feeds remains unsettled. Calling it a stable infrastructure layer is premature.

Use Cases
  • Quant researchers building agent-accessible market data pipelines with OpenBB
  • Developers tracking AI model pricing via a structured, versioned database
  • Education startups modeling curriculum graphs for adaptive math diagnostics

Deep Cuts

Eridanus Turns Chat Bots Into Function-Calling Agents Built on OneBot 🔗

Its LLM-driven dispatcher runs even without QQ, powering Live2D desktop companions from one Python codebase.

AOrbitron/Eridanus · Python · 208 stars

Most QQ bots still match keywords to commands. Eridanus replaces that with LLM function calling at its core, so the model decides which tool to invoke based on conversation rather than rigid syntax.

It speaks the OneBot 11 protocol, which means it plugs into existing QQ infrastructure, and it supports both openai-api and gemini-api backends. The framework is written in Python and ships with its own plugin structure for adding capabilities.

The most unusual feature: it runs without QQ at all. A pure Live2D desktop-pet mode lets the same agent logic drive an on-screen character. That makes it a useful reference for anyone building an assistant that isn't tied to one chat platform.

The catch: It has only 208 stars, sparse outside Chinese-language documentation, and the function-calling layer has seen little independent testing.

Use Cases
  • Chinese-speaking developers building QQ group assistants with LLM-driven tool use
  • Hobbyists creating Live2D desktop companions powered by OpenAI or Gemini models
  • Framework builders studying OneBot-based function-calling dispatch as a reference design

Source: AOrbitron/Eridanus — based on the project README.

Quick Hits

scrawl Lets an agent see the problem for itself: annotate a screenshot, record a quick screen capture, and send both off as a ready-to-use bug report. 529
DeepInfer Offers a high-performance framework for running DeepSeek models at scale, aimed at teams who need fast, large-batch inference without building their own serving stack. 6.8k
ios-sweet Ports iOS 16 userland and an XNU kernel onto the Redmi Note 10 Pro (codename sweet, Snapdragon 732G), an interesting experiment for anyone curious about running Apple's stack on Android hardware. 623
motion-prompt No description was provided for this repository, so there is not enough information to summarize what it does or why it's worth a look. 525
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

PyTorch's Latest Release Patches Silent Errors in Apple and NVIDIA Math Kernels 🔗

Version 2.14.1 fixes wrong SVD and least-squares results on Apple Silicon and updates CUDA 13.2 binaries to address two NVIDIA-side bugs.

pytorch/pytorch · Python · ▲ 31 in 1d Est. 2016 · Latest: v2.14.1

PyTorch v2.14.

1 is a correctness release. Most of its fixes target results that were wrong without raising an error, the category most likely to slip into a training run or a numerical pipeline unnoticed.

On Apple Silicon, torch.linalg.lstsq could return incorrect solutions for complex batched underdetermined systems. torch.linalg.svd could produce a non-orthogonal U and inaccurate small singular values on rank-deficient or ill-conditioned inputs. A separate Metal pipeline-state failure blocked svd, svdvals and lstsq on MPS for inputs above 8,192 elements. Those are now addressed.

On the NVIDIA side, the CUDA 13.2 Linux binaries move to CUDA 13.2.2. NVIDIA's update fixes two defects: cublasLtMatmul() could ignore tensor-wide scaling for NVFP4 matrix multiplications, and failed thread reconvergence could leave stale register values in kernels with nested divergence. The second bug dates to CUDA 12.8, so builds on that toolchain may have been affected for some time.

For teams running mixed Apple and NVIDIA hardware, the practical step is to pin to 2.14.1 and rerun any linear-algebra-heavy evaluation that previously passed.

The catch: The release fixes bugs but does not explain how many users hit them or whether earlier results need recomputing. Teams should check whether their outputs depended on the affected code paths before assuming prior runs were sound.

Previously in The Times “covered” — Oct 15

Use Cases
  • ML engineers on Apple Silicon running SVD or least-squares in production pipelines
  • Researchers using NVFP4 matrix multiplications on CUDA 13.2 hardware
  • Scientific computing teams validating prior PyTorch linear-algebra results after upgrading

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

More Stories

Superpowers Rebuilds Agent Brainstorming to Pin Down Requirements Before Code 🔗

Version 7.0.0 adds a native Antigravity plugin and fixes Windows hook discovery across agent harnesses

obra/superpowers · Shell · 302.4k stars Est. 2025

The obra/superpowers framework now steers coding agents to clarify what you want before they write a line. Its rebuilt brainstorming skill asks what you're after and why, plays back what it heard, and keeps questioning until the picture is clear.

It then sizes the task, from a quick change to a full design document.

Approved designs become implementation plans, which subagent-driven-development executes task by task, with agents reviewing each other's work. The framework emphasizes red/green TDD, YAGNI and DRY.

The v7.0.0 release also adds:

  • A native plugin manifest for the Antigravity Marketplace
  • Fixes for Windows hook discovery and Git Bash paths
  • Repairs to Hermes skill descriptions

Skills trigger automatically, so no special invocation is needed. Installation varies by harness, and users running several must install it for each.

The catch: With 387 open issues and a methodology that lets agents run for hours unsupervised, builders must judge whether the upfront spec and review loop suits their codebase.

Use Cases
  • Solo developers wanting agents to clarify requirements before writing code
  • Engineering teams running long autonomous agent sessions against approved implementation plans
  • Developers using multiple coding agents who want one shared TDD methodology

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

OpenAI Cookbook Keeps Developers Current on API Patterns 🔗

The Jupyter-based repository has drawn nearly 13,000 forks and now serves as a working reference for `gpt-4`-era integrations.

openai/openai-cookbook · Jupyter Notebook · ▲ 21 in 1d Est. 2022

The openai/openai-cookbook repository collects runnable notebooks showing how to perform common tasks with the OpenAI API. Its latest push landed this week, and its last commit is recent, meaning the examples track the current client.

Setup is simple. Developers set an OPENAI_API_KEY environment variable, or drop the key into a .env file that the notebooks read. Most examples are in Python, though the patterns transfer to other languages.

The repository is MIT-licensed, and its topic tags cover chatgpt, gpt-4, and openai-api. Forks have grown to nearly 13,000, a sign that teams are copying the notebooks as starting points.

The catch: With 326 open issues, some examples may lag behind API changes, so verify each notebook against current endpoints before shipping it.

Previously in The Times “covered” — Oct 14

Use Cases
  • Backend engineers prototyping chat completions in Python notebooks
  • Teams building retrieval pipelines against current OpenAI embedding endpoints
  • Developers migrating legacy API calls to newer model interfaces

Source: openai/openai-cookbook — based on the project README.

Quick Hits

OpenBB Pulls financial, economic and market data into one platform that analysts, quants and AI agents can query directly. 74.5k
AutoGPT Offers tooling for building and running autonomous AI agents, aiming to make AI accessible to anyone who wants to build on it. 187.7k
firecrawl Lets AI agents gather and structure live web data, turning pages and sites into clean inputs for models. 193.3k
mcp-for-beginners A hands-on curriculum teaching Model Context Protocol across six languages, covering secure, modular AI workflows and service orchestration. 17.5k
FinRL Applies reinforcement learning to trading and portfolio problems, providing ready-made environments for building and testing financial agents. 16.8k
ComfyUI Runs diffusion image and video models through a node-based graph interface, with an API and a fast local inference backend. 140.4k

PX4 v1.17 Adds Altitude Cruise and Native ROS 2 Fixed-Wing Control 🔗

The open-source autopilot now ships Gazebo Jetty support, Zenoh middleware compatibility, and three new INS drivers.

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

PX4, the open-source autopilot stack for drones and unmanned vehicles, has shipped v1.17.

The release targets builders running multicopters, fixed-wing aircraft, and VTOLs who need steadier flight behavior and tighter ROS 2 integration.

The headline change is Altitude Cruise, a new multicopter mode. On stick release it holds tilt and heading and keeps the vehicle moving at a steady velocity. Standard Altitude mode stops the vehicle instead.

Fixed-wing takeoff also changed. On navigation loss, the vehicle now keeps climbing with level wings. It can also use the takeoff waypoint's coordinates to set the loiter position.

For ROS 2 developers, fixed-wing and VTOL-in-fixed-wing-mode vehicles can now be controlled through a new high-level setpoint interface. The in-tree Zenoh middleware moves toward rmw_zenoh compatibility. Simulation adds Gazebo Jetty support and Ackermann SIH. New INS drivers cover MicroStrain, sbgECom, and EULER-NAV.

PX4 runs on NuttX, Linux, and macOS under a BSD 3-Clause license, and is hosted by the Dronecode Foundation under the Linux Foundation.

The catch: The project carries 478 open issues, and the new ROS 2 and Zenoh paths are recent. Teams relying on them should test against their own hardware before flight.

Previously in The Times “covered” — Oct 16

Use Cases
  • Drone developers building multicopters needing steady cruise behavior
  • ROS 2 engineers controlling fixed-wing aircraft through high-level setpoints
  • Survey operators integrating new GNSS and INS sensor drivers

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

More Stories

Mission Planner Keeps ArduPilot Drones Under Ground Control 🔗

Open-source C# station adds localization, Mavlink2 signing and DroneCAN multicast support in its 1.3.83 release

ArduPilot/MissionPlanner · C# · 2.4k stars Est. 2013

Mission Planner, the Windows ground control station for the ArduPilot autopilot, is still shipping updates. Release 1.

3.83 adds UK localization fixes, Mavlink2 signing visibility in the authentication keys screen, and DroneCAN multicast support.

The changes also tighten existing tools. Recent commits fix parameter rounding to seven digits, cap thrust expo at 0.80 in initial setup, and add elevation and terrain overlays to the propagation view.

For builders, the most practical items are:

  • Signed Mavlink2 links, which help protect commands sent to the vehicle
  • Multicast DroneCAN, for networked peripherals
  • Safety-switch checks that require a valid target system

Development runs in Visual Studio 2022, with a configuration file for setup. Linux builds are also supported.

The catch: the project carries roughly 1,375 open issues, and its Windows-centric toolchain makes Linux and VSCode users work harder to build from source.

Use Cases
  • Drone operators planning and monitoring ArduPilot missions on Windows laptops
  • Hobbyists and engineers tuning Pixhawk and Cube flight controllers via parameters
  • Developers building and modifying the open-source ground station in C#

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

Browser-Based Tool Lets Engineers Build Robot Models Without Raw XML 🔗

Editor exports to MuJoCo and adds AI-assisted generation, collision optimization, and hardware parameter setup in one workspace.

OpenLegged/URDF-Studio · TypeScript · 490 stars 10mo old

Writing URDF files by hand means editing raw XML for every joint, link and mesh. URDF Studio replaces that loop with a browser-based visual editor built on TypeScript and React Three Fiber.

The app handles the core workflow in one place:

  • Topology editing: build and modify kinematic trees with link and joint tools.
  • Geometry and collision: author visual and collision meshes, measurements and optimization strategies.
  • Hardware configuration: set motor, transmission, damping and friction values.
  • Export: write URDF and MuJoCo output, with multi-robot assembly and an AI assistant for generation and review.

The latest release, v1.0.0, adds version display and bump scripts. It is a housekeeping milestone rather than a feature change.

The catch: the project shows one open issue and 57 forks, and its public release history is thin. Builders should test MuJoCo and collision export against their own robots before trusting it in a pipeline.

Use Cases
  • Robotics researchers editing URDF topology without writing raw XML
  • Simulation engineers exporting robot models to MuJoCo for testing
  • Hardware teams defining motor and transmission parameters for robot models

Source: OpenLegged/URDF-Studio — based on the README and release notes.

evo Gives Robotics Teams One Tool to Score Odometry and SLAM 🔗

Python package reads TUM, KITTI, EuRoC and ROS bagfiles, then compares trajectories with alignment, scale and plotting options

MichaelGrupp/evo · Python · ▲ 2 in 1d Est. 2017

Researchers and robotics engineers comparing odometry or SLAM output often write their own scripts for every dataset format. evo replaces that with one package.

It reads TUM trajectory files, KITTI pose files, EuRoC MAV groundtruth, and ROS and ROS2 bags carrying PoseStamped, Odometry or TF messages. It handles association, alignment and monocular scale adjustment, then outputs plots, LaTeX figures or Excel tables.

The latest release supports Python 3.11 and later. Install it inside a virtual environment, with pipx, uv or Pixi, not with sudo pip.

The project is not a drop-in replica of any single benchmark protocol. Teams needing an exact published method must still check their numbers against that protocol.

The catch: the package is a mature but narrow tool with six open issues, so teams with unusual trajectory formats should test it on their own data first.

Use Cases
  • Robotics researchers comparing SLAM algorithms across TUM and KITTI datasets
  • Engineers scoring odometry output recorded in ROS2 bagfiles
  • Academics exporting trajectory error plots as LaTeX figures for papers

Source: MichaelGrupp/evo — based on the project README.

Quick Hits

carla Lets autonomous-driving researchers test perception, planning, and control algorithms in realistic simulated urban environments with configurable sensors, traffic, and weather. 14.5k
PythonRobotics Pairs readable Python implementations of core robotics algorithms, from localization and mapping to path planning and control, with the explanations to go with them. 30.7k
autoware_universe Provides a modular open-source software stack for self-driving vehicles, covering perception, planning, and control, with a focus on production-grade autonomy. 1.8k
cs-video-courses Curates links to full computer science courses with video lectures, letting self-taught learners follow a structured university-style curriculum at no cost. 83.7k
mujoco Delivers a fast, accurate physics engine for multi-joint robots with contact dynamics, widely used for robotics control, reinforcement learning, and biomechanics research. 15.8k

OpenAI's Codex Security Adds Investigation Time Budgets for Scans 🔗

Release 0.5.0 lets teams cap scan duration and lets hosts run validation and severity triage on their own model execution.

openai/codex-security · TypeScript · ▲ 6 in 1d 3mo old · Latest: npm-v0.5.0

OpenAI's codex-security CLI and TypeScript SDK now let teams bound how long a vulnerability scan runs. Version 0.

5.0, published to npm as @openai/codex-security, adds an investigation time allowance, set with codex-security scan . --max-time 15, the SDK's maxTimeMinutes, or the project setting scan.max_time_minutes. Values are positive minutes, fractions included.

The allowance behaves differently by scan type. Standard and diff scans treat it as advisory. Deep Scan, which runs parallel discovery workers across a repository, enforces it during discovery before combining completed findings. Reporting can continue past the deadline, so a scan that hits its limit still produces saved output.

The release also adds host-provided finding reviews. codex-security validate --records checks candidate findings against source code, and codex-security classify-severity --records scores canonical reports against a supplied severity rubric. Both run on model execution the host supplies, and classification needs no repository or saved scan. That makes the triage step usable inside a team's own pipeline rather than only in a standalone scan.

Version 0.5.0 also retires the advisory capability preflight. Custom integrations that depended on it need to follow the migration guidance in the release notes.

The catch: Requirements are strict: Node.js 22.13.0 or later in the 22.x line, or Node.js 24.x or 26.x, plus Python 3.10 or newer. The project shows 197 open issues, and the time budget is advisory outside Deep Scan, so a standard scan can run past its limit.

Previously in The Times “covered” — Oct 17

Use Cases
  • CI maintainers capping security scan duration on every pull request
  • Platform teams embedding finding validation into internal security pipelines
  • Security engineers triaging scan output against their own severity rubric

Source: openai/codex-security — based on the README and release notes.

More Stories

Open-Source Cybersecurity Course Ships 70 Full Projects in Go and Python 🔗

Projects run from first-time-coder Foundations to advanced tiers, with 10 certification career roadmaps attached.

CarterPerez-dev/Cybersecurity-Projects · Go · 8.4k stars 11mo old

A GitHub repository from developer CarterPerez-dev now offers 70 hands-on cybersecurity projects with full source code, organized into four tiers: Foundations, Beginner, Intermediate, and Advanced.

The Foundations tier targets people who have never written Python or used a terminal.

Its tools are single files with heavy inline teaching comments and docstrings on every function. Later tiers assume the reader already knows the language.

The repository also includes:

  • 10 career roadmaps, covering SOC Analyst, Pentester, Security Engineer, and GRC Analyst
  • Curated tools, courses, and certifications for working professionals

The project has drawn 1,216 forks, and its maintainer is building a DDoS Mitigation Tool now.

The catch: the repository is roughly a year old, its listed projects are largely self-contained, and its guided-course companion is a separate platform, so learners who want walkthroughs must look beyond the source code.

Use Cases
  • Career-changers without programming experience learning Python through single-file security tools
  • SOC analysts following a certification roadmap toward a Security Engineer role
  • Students building a portfolio of intermediate-level pentesting and cybersecurity projects

Source: CarterPerez-dev/Cybersecurity-Projects — based on the project README.

SWE-agent Ships Training Data That Lifts Open Models to Top of SWE-bench 🔗

Companion project SWE-smith generates tens of thousands of agent trajectories; the new release also breaks existing trajectory files.

SWE-agent/SWE-agent · Python · 20.6k stars Est. 2024

SWE-agent takes a GitHub issue and uses a language model of choice to attempt a fix. Its latest release, v1.

1.0, adds a companion project, SWE-smith, that generates tens of thousands of training trajectories for software agents.

The maintainers say a model trained on that data, SWE-agent-LM-32b, reaches open-weights state of the art on SWE-bench Verified when run through SWE-agent.

The release also changes things builders must handle:

  • Trajectory files replace the messages field with query.
  • Several tool bundles were renamed, and review_on_submit was removed in favor of review_on_submit_m.
  • Multilingual and multimodal SWE-bench support is now included.

Note that the team now steers most effort toward mini-SWE-agent, which they say matches SWE-agent's performance in far less code.

The catch: the project carries 163 open issues, and the main development focus has shifted to mini-SWE-agent, so teams starting fresh should evaluate both before committing.

Previously in The Times “covered” — Oct 13

Use Cases
  • Research teams training open-weights coding agents on SWE-smith trajectories
  • Engineering teams benchmarking LM choices against SWE-bench Verified
  • Security researchers running SWE-agent-based agents on capture-the-flag challenges

Source: SWE-agent/SWE-agent — based on the README and release notes.

RustScan Locks In Speed Guarantees With Automated Benchmarks 🔗

Latest release adds a library API and CI checks that block any change slowing the port scanner

bee-san/RustScan · Rust · 20.6k stars Est. 2020

RustScan's 2.4.

1 release makes speed a enforced property rather than a claim. Continuous integration now fails any pull request that makes the scanner measurably slower than the previous version.

The project added benchmarks for both TCP and UDP scanning, monitored with hyperfine. Maintainers also reduced clone() calls and deduplicated input to protect throughput.

The release also ships a RustScan library, so Rust developers can embed scanning directly in their own tools rather than shelling out to the binary.

Other changes include fixes that stop duplicate IP addresses and mark timed-out UDP ports as closed instead of open. The scanner still pipes results into nmap and supports Python, Lua and shell scripts.

The catch: the project has 18 open issues, and the speed guarantee depends on benchmark coverage that must keep pace with new scan types.

Previously in The Times “covered” — Oct 13

Use Cases
  • Penetration testers scanning large networks needing fast initial port discovery
  • Rust developers embedding port scanning into custom security tooling via the library
  • Sysadmins piping open ports automatically into Nmap for service enumeration

Source: bee-san/RustScan — based on the README and release notes.

Quick Hits

sherlock Searches dozens of social networks at once to find which sites a given username is registered on. 94.6k
hacktricks A crowdsourced knowledge base of offensive security techniques, CTF tricks, and research notes for pentesters and red teamers. 12.6k
sniffnet A cross-platform desktop tool that lets you watch network traffic in real time, with clear visuals of where your data is going. 41.7k
Osintgram An interactive shell for profiling Instagram accounts by username, pulling followers, posts, comments, and other public account data for analysis. 15.1k
bbot A recursive scanner that chains reconnaissance modules together to map out an organization's attack surface from a single starting domain. 10.7k

ClickHouse Ships Real-Time Analytics Engine Built for Columnar Speed at Scale 🔗

Latest stable release v26.9.22.3 extends the C++ OLAP database that powers analytics queries across distributed clusters and lakehouse setups.

ClickHouse/ClickHouse · C++ · ▲ 11 in 1d Est. 2016 · Latest: v26.9.22.3-stable

ClickHouse, the open-source column-oriented database, continues to shift how teams run analytical queries over large datasets. The project's latest stable release, **v26.

9.22.3**, arrives with the codebase still in active development, with the most recent push landing today.

The system stores data by column rather than by row. That layout lets it scan only the fields a query touches, which keeps aggregations over billions of rows fast on commodity hardware. The engine is written in C++ and speaks SQL, so existing analysts and tooling can connect without rewrites.

Builders are using it across three patterns:

  • Real-time dashboards that refresh from streaming event data
  • Lakehouse analytics querying data in object storage
  • Embedded OLAP inside applications that need fast internal reporting

The project also ships a cloud-hosted option, ClickHouse Cloud, for teams that prefer not to operate clusters. The release cadence is quarterly-plus, with multiple stable versions in 2026 alone, which signals an active maintainer team.

The catch: The repository carries more than 8,500 open issues, a volume that reflects both the codebase's breadth and a backlog teams should weigh. Operating a self-hosted distributed cluster demands real database expertise, and the system is optimized for analytical reads rather than transactional writes, so it will not replace an OLTP store.

Previously in The Times “covered” — Oct 19

Use Cases
  • Data engineers building real-time analytics dashboards over streaming event pipelines
  • Platform teams querying lakehouse data in object storage with SQL
  • Application developers embedding fast OLAP reporting into product features

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

More Stories

Traefik Fixes Three CVEs and Tightens HTTP CONNECT Handling 🔗

Release v3.7.15 patches three security advisories and rejects CONNECT requests before they reach the muxer.

traefik/traefik · Go · 65.3k stars Est. 2015

Traefik, the Go-based reverse proxy and load balancer, shipped v3.7.

15 with fixes for three published security advisories. The release also hardens how the proxy handles HTTP CONNECT requests.

The update rejects CONNECT regardless of HTTP version and blocks the method before it reaches the muxer. Kubernetes users get several fixes, including:

  • Ingress-nginx compatibility: auth-tls client authentication now applies to the whole host, and a cross-namespace check on shared auth-tls-secret TLS options is corrected.
  • Gateway API: the sigs.k8s.io/gateway-api dependency moves to v1.6.3, and HTTPRoute backends default to HTTP when no appProtocol is set.

Operators on the v3 line should read the migration guide before upgrading.

The catch: the project carries 949 open issues, and the release notes do not state which of the three advisories are rated most severe.

Use Cases
  • Platform teams running Traefik as a Kubernetes ingress controller for multi-tenant clusters
  • Operators migrating ingress-nginx annotations, such as `auth-tls`, to Traefik
  • DevOps engineers patching internet-facing reverse proxies against recently disclosed advisories

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

Git Keeps Its Mailing-List Workflow as GitHub Mirror Stays Publish-Only 🔗

Pull requests reach maintainers through GitGitGadget, which converts them into patches for the project's long-running mailing list.

git/git · C · ▲ 10 in 1d Est. 2008

Git, the distributed version control system written in C, is still developed the way it was launched in 2005: on a mailing list. The GitHub repository is a publish-only mirror.

Contributors cannot merge changes there directly.

Instead, pull requests are converted into patches by GitGitGadget and posted to the list, where review happens. Contributors must follow the project's Documentation/SubmittingPatches procedure.

The mirror's activity is steady, with its most recent push on 20 October 2026 and about 405 open issues. Development is spread across C and shell code.

The catch: the mirror's issue tracker is a poor guide to where decisions happen. Anyone expecting a GitHub-style merge flow will find the review process slower and more formal than typical open-source workflows.

Use Cases
  • Open-source maintainers tracing how Git's changes reach production releases
  • Contributors preparing patches for review on the Git mailing list
  • Engineers auditing Git internals in C for security or performance work

Source: git/git — based on the project README.

Quick Hits

ladybird Builds a truly independent web browser from scratch, free of the engine monocultures that dominate today's web. 66.6k
photocraft Delivers a full-featured photo editor written entirely in pure Rust, giving you a memory-safe, open-source alternative for image work. 69.1k
colibri Runs frontier mixture-of-experts models on hardware you already own, streaming experts from disk in a dependency-free C engine. 43k
tmux Provides the complete source of tmux, the terminal multiplexer, for anyone wanting to study, modify, or contribute to it. 49.9k
native Offers a toolkit for building native desktop applications in Zig, aiming for lean binaries without a web runtime. 7.8k
electron Lets you build cross-platform desktop apps using JavaScript, HTML, and CSS, packaged with a Chromium-based runtime. 123.4k

OpenIPC Firmware Extends Open Camera Software Across a Widening Chip Range 🔗

Latest nightly build spans chips from Ambarella to SigmaStar, while the team sells paid support to fund full-time development.

OpenIPC/firmware · C · ▲ 4 in 1d Est. 2021 · Latest: nightly

OpenIPC's firmware now targets far more than its original HiSilicon base. The project's README lists support for chips from Ambarella, Anyka, Fullhan, Goke, GrainMedia, Ingenic, MStar, Novatek, SigmaStar and XiongMai, with more expected.

For owners of cheap IP cameras locked into vendor firmware, that breadth matters: one open image can replace proprietary software across multiple hardware families.

The project is written in C and built on Buildroot and U-Boot. Its latest nightly build, from commit 5e914f7 and built October 19, ships with a checksummed web UI. Development is split across two tiers: free community support via chat, and paid commercial support from core developers, with revenue flowing through Open Collective.

Contributors are pointed to CLAUDE.md and AGENTS.md before submitting patches, a sign the tree has grown complex enough to need formal contributor guidance.

The catch: The project has 171 open issues, and it ships only nightly builds rather than tagged stable releases. Support breadth is also uneven: a chip appearing in the README does not guarantee every camera model on that SoC works. Businesses should verify their specific hardware before committing to a deployment.

Previously in The Times “covered” — Oct 17

Use Cases
  • Hobbyists replacing locked vendor firmware on budget IP cameras
  • FPV and drone builders adapting camera hardware with open software
  • Businesses deploying cameras needing paid firmware support contracts

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

More Stories

Nexting Lets Builders Drive Their AI Agents From a Wearable 🔗

Wearable PIN ships at $129 while Android 3.0.1 widens direct-install reach to millions of phones

Nexting-ai/nexting · C · 1.9k stars 7mo old

Nexting connects a phone or wearable to agents already running on a Mac or Windows PC. Users can view live sessions, send tasks, and steer Claude Code, Codex, Grok, and Cursor remotely.

The hardware is the new part. The PIN, a collar-mounted device priced at $129, is shipping now. A ring-form Ring remains in private beta. Both pair over Bluetooth and dispatch a spoken task in about three seconds.

The latest Android build, 3.0.1, targets Android 8.0 and newer and is available as a signed APK for direct download or as an AAB for Google Play.

Setup runs through a one-line installer that binds the computer to a Nexting account and starts a background daemon to keep the phone connected.

The catch: the project is about seven months old, carries two open issues, and depends on an account-bound daemon on your own machine, so it is worth auditing that trust boundary before wiring it to production agents.

Use Cases
  • Developers dispatching Claude Code tasks from a phone while away from desk
  • Engineers monitoring long-running Cursor sessions on a home workstation remotely
  • Hardware tinkerers building voice-driven control surfaces for personal AI agents

Source: Nexting-ai/nexting — based on the README and release notes.

ESP32 Voice Companions Gain Local Models and Cloudflare Edge Pipelines 🔗

Open-source stack now runs 100+ speech models, including fully on-device LLMs and TTS, on cheap microcontroller hardware.

akdeb/ElatoAI · TypeScript · 2.1k stars Est. 2025

ElatoAI has been wiring realtime voice AI to ESP32 microcontrollers since April 2025. Its latest changes widen what a builder can run on cheap hardware.

The March 2026 update added local AI toys: ESP32 devices can now drive on-device models such as Qwen and Mistral through MLX. Cloudflare's Voice Agents and Durable Objects, announced in April, add a path to a globally scaled device network with Deepgram speech I/O bundled in Workers AI. A FastAPI server built on Pipecat lets developers assemble their own pipelines from the 100+ supported models.

The project's core remains secure WebSocket streaming for conversations lasting over 20 minutes.

The catch: the repository has six open issues and no stated hardware-performance benchmarks, so latency and battery life on real ESP32 boards remain untested in public.

Use Cases
  • Hobbyists building talking desk companions on ESP32 boards with cloud LLMs.
  • Toy makers prototyping offline voice devices using on-device Qwen models.
  • Startups deploying fleets of voice-enabled devices through Cloudflare Workers.

Source: akdeb/ElatoAI — based on the project README.

Open-Source Robot Duck Brings Legged Robotics to the Hobby Bench 🔗

Fifteen servos, an Arduino UNO Q and printable parts form a biped builders can assemble and modify.

LuwuDynamics/xgoduck_hardware · Unknown · 687 stars 3w old

Luwu Dynamics has released XGO-Duck, a duck-shaped biped robot adapted from Pollen Robotics' Microduck. The repository is the hardware starting point: printable structure, mechanical models, PCB designs, a bill of materials and an assembly guide.

The build centers on:

  • Fifteen Feetech 1910 serial servos
  • An Arduino UNO Q controller
  • A custom expansion board with an IMU and servo interfaces
  • A movable head and beak, driven by a separate mouth servo

Companion repositories supply the onboard runtime and reinforcement-learning tools, so builders can move from assembly to motion experiments. The motion policy targets 14 joints.

The project has drawn 90 forks and five open issues. A recent hardware correction reverses GND and SIGNAL on three components of the older board, so owners of early boards must rewire before powering up.

The catch: the maintainers warn the hardware is for learning and testing only, and that mass-production PCB fabrication is not recommended.

Previously in The Times “covered” — Oct 15

Use Cases
  • Hobbyists building a low-cost legged robot for learning locomotion control
  • Robotics students testing reinforcement-learning policies on physical hardware
  • Makers adapting printable biped designs into custom animatronic or character projects

Source: LuwuDynamics/xgoduck_hardware — based on the project README.

Quick Hits

LibreHardwareMonitor Monitors temperatures, fan speeds, voltages, loads, and clock speeds across your PC's hardware, all in free, open-source software. 9.2k
pxt-maker Provides a MakeCode toolchain for Maker boards, letting you program them in blocks or TypeScript from a browser-based editor (currently in beta). 130
ghdl Simulates VHDL designs across the 87, 93, and 2008 language standards, letting you verify hardware logic without physical chips. 2.9k
Clawdmeter Turns an ESP32 into a small desk display that tracks your Claude Code usage in real time. 2.3k
TuyaOpen Offers an AI-plus-IoT framework for T2, T3, T5AI, ESP32, and other chips, speeding up hardware integration for AI agents and connected devices. 1.9k

PlayCanvas Engine Pushes Gaussian Splatting Into Mainstream Browser Workflows 🔗

Latest release fixes render-container warnings as the open-source runtime keeps expanding WebGPU and splat support for browser-based 3D.

playcanvas/engine · JavaScript · ▲ 3 in 1d Est. 2014 · Latest: v2.23.3

The playcanvas/engine runtime is an open-source 3D engine written in JavaScript that targets WebGL2 and WebGPU directly in the browser. Its newest tagged release, v2.

23.3, is a narrow fix, but the surrounding feature set shows where the project is heading.

The engine's most distinctive recent emphasis is first-class support for 3D Gaussian Splatting. Splats are loaded and rendered as native scene content rather than through a bolt-on plugin, which matters for builders producing photogrammetry-style captures and volumetric environments for the web.

For developers, the practical surface includes:

  • Physics through the ammo.js rigid-body integration
  • XR via WebXR for AR and VR sessions
  • Assets streamed asynchronously over glTF 2.0, with Draco and Basis compression
  • Scripting in TypeScript or JavaScript

Release v2.23.3 changes one behavior: render containers that were never registered now trigger warnings only when preload begins, cutting noise for projects that register containers late. The release is a patch, not a platform shift.

The catch: The repository carries 463 open issues, and the engine's breadth means many of its subsystems move at different speeds. Teams betting on the newest rendering path, particularly WebGPU and splatting, should test on their target devices before committing.

Previously in The Times “covered” — Oct 16

Use Cases
  • Browser game studios shipping cross-device titles built on WebGL2 and WebGPU
  • Marketing and visualization teams embedding interactive 3D product views on websites
  • XR developers building WebXR AR and VR experiences without native app stores

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

More Stories

Pixelorama Adds Locked Guides and Cel Cloning in Latest Release 🔗

Open-source pixel art editor, built on Godot 4.7, now ships with guide locking, Shift-drag cel duplication, and a bucket-tool freeze fix.

Orama-Interactive/Pixelorama · GDScript · ▲ 8 in 1d Est. 2019

The open-source pixel art editor Pixelorama has shipped v1.2.

3, adding three workflow features and fixing a notable crash.

What changed:

  • Guides can now be locked in place from the View menu.
  • Holding Shift while dragging a cel clones it on the timeline.
  • Cel content can be centered from the timeline's right-click menu.
  • The bucket tool no longer freezes Pixelorama when a selection is active.

The release is built on Godot 4.7.2 and runs on Windows, Linux, macOS, and the web. The project is roughly seven years old, with stable builds distributed through Steam, Itch.io, Flathub, and WinGet.

The catch: The project carries 85 open issues, and the update is a point release, so animators relying on the bucket tool should confirm the fix against their own selections.

Use Cases
  • Indie game developers creating sprite sheets and tile sets for Godot projects.
  • Pixel artists animating characters with onion skinning and frame tags.
  • Educators teaching pixel art fundamentals with a free, cross-platform editor.

Source: Orama-Interactive/Pixelorama — based on the README and release notes.

Tiled 1.12.2 Tightens Map Editor's Property Handling for Game Builders 🔗

Patch release fixes copy-paste and locale bugs in the open-source tile map editor used across tile-based games

mapeditor/tiled · C++ · ▲ 5 in 1d Est. 2011

Tiled, the general-purpose tile map editor, shipped version 1.12.

2 this week with a set of bug fixes rather than new features. The release targets the Properties view and related editor widgets.

What changed:

  • Copy/paste of list properties no longer drops item types
  • Properties view no longer sticks with updates disabled
  • Number parsing respects the user's locale in expression-capable spin boxes
  • Runtime language switching works in more widgets
  • Multi-object selection bounding boxes handle point objects correctly

For builders, the fixes matter because custom properties on maps, layers, tiles and objects are central to the TMX workflow. Tiled's flexibility, with arbitrary map sizes and multiple tilesets per map, depends on those properties behaving predictably.

Binaries are available for all major platforms, and Qt 6.2 or later is required to compile from source.

The catch: With 840 open issues and a point release, the project is mature but its issue backlog is large, so some reported bugs will remain unresolved.

Use Cases
  • Indie game developers building 2D RPG or platformer levels using custom tile properties.
  • Level designers exporting TMX maps for engines that parse list-valued object properties.
  • Localized-toolchain teams editing numeric map values in non-English locales.

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

Flame Engine Brings Flutter Games to Its Third Major Era 🔗

Latest release republishes the `flame_3d` bridge for Flutter 3.47, letting 3D components join the 2D component tree.

flame-engine/flame · Dart · 10.8k stars Est. 2017

Flame, the Dart game engine built on Flutter, has spent nearly nine years giving Flutter developers the plumbing games need: a game loop, a component system, collision detection, and input handling. What's new is the 3D path.

The flame_3d_component bridge adds 3D components to Flame's component tree, built on flutter_scene.

The most recent release, flame_3d-v0.3.2, is narrow. It republished the package with a Flutter 3.47.0 constraint so it installs cleanly on current toolchains. For builders, the point is that the 3D bridge is now usable against the Flutter version most teams are on.

Flame also ships official bridges for flame_audio, flame_behavior_tree and others, so a project can extend the engine without leaving the Flame component model.

The catch: the 3D bridge is at version 0.3, and the repository carries 82 open issues, so teams should check that the features they need are stable before committing a production title.

Use Cases
  • Indie Flutter developers building 2D games without a separate engine.
  • Teams adding 3D scene elements to an existing Flame project.
  • Developers prototyping game mechanics in Dart with a shared component model.

Source: flame-engine/flame — based on the README and release notes.

Quick Hits

Babylon.js Builds fully featured 3D games and interactive rendering experiences in the browser with a simple, well-documented JavaScript framework. 26.2k
egui Lets you create responsive immediate-mode user interfaces in Rust that compile and run unchanged in both the browser and native desktop apps. 31.6k
ebiten Provides a minimal, approachable toolkit in Go for building 2D games that run across desktop, mobile, and the web. 13.6k
shader-skills Offers a collection of reusable GLSL shader techniques for learning and applying visual effects in graphics programming. 227
Greater-Flavor-Mod Expands the Historical Flavor Mod for a grand strategy game with added provinces, flavour content, and revised historical accuracy. 244
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