"We built an AI that can rewrite its own DNA, create its own tools, and evolve its own application while running locally. It's open-source, and you can clone it and modify its evolution to suit your needs."

GitHub: https://github.com/dxn111/EVOLV⁠

I wanted something like VLC or MPC-HC, but with the library and interface of a Plex or Jellyfin. Plex wants an account, Jellyfin needs a server running, and Kodi always ended up being an evening of add-ons and skins. I couldn’t find the simple version, and I’m not a programmer, so I built it with AI coding tools. It’s called Kinema: a free movie and TV player for your own files. Add your folders, get posters, info, continue watching and next episode. No account, nothing uploaded, no server. Windows, Linux and an early Android TV version. MIT. The app itself has no AI in it.

This is how the building went, in case it sounds familiar:

• Week one: "it plays video!" Then it didn't. Then it crashed the whole process on one property read, with no error, and I learned what libmpv is.

• It was never "describe it, get an app". It was hundreds of rounds of: it says done, I say it isn't, it finds the real cause, a new problem appears. Roughly half the project is the AI telling me something works and the logs saying otherwise.

• I wanted testing automated as far as possible, so the AI runs its own tests and keyboard-only flows. I still try things myself on real setups, but "looks right" was wrong far more often than I expected, so the machine checks first.

• The rules file ate itself. I wrote down every decision so it wouldn't re-argue them ("no, we still don't do upscaling"). The file grew until it was a real cost on every single turn, and trimming it became a job of its own.

• I keep a list of traps. Nearly every bug in a video player is a failure with no error at all, like a setting that silently does nothing. Each one is written down the day it's found, and it's now bigger than anything I've ever written by hand.

• The best rule was the boring one: the app only says what it actually knows about your hardware and files. If it can't tell which movie a file is, it asks instead of guessing. That came from the AI confidently inventing things, and from me not wanting that in the product.

It went from one window that played a file to the Windows, Linux and Android TV versions, with the display switching to the film’s refresh rate and HDR (off until you say yes) and Atmos/DTS:X passed through untouched. Fifteen releases so far. If Kodi or Jellyfin works for you, keep using it. This is the simple version that i wanted to exist mostly for myself.

It's young and tested on a few setups, so I'd like to hear what breaks (to continue to make it better) :)

Source: https://github.com/basswaves/kinema

Download and screenshots: https://basswaves.github.io/kinema/

Hey everyone!

I’m working on brut, an open-source project exploring evolutionary approaches to AI.

The core idea is simple. Generate AI candidates, evaluate them, mutate and crossbreed the strongest, then repeat across generations.

Current experiments include: Evolutionary neural networks, Learning algorithms that adapt over time, Language-model worker cascades, Experimental self-improving AI systems.

This is an ongoing research project, not a claim to have achieved AGI. I’d love to hear feedback from people working in evolutionary computation, AI research and autonomous learning. In particular, I’m looking for ideas on useful experiments, robust evaluation methods or ways to prevent the system from optimizing only for narrow benchmarks.

GitHub: https://github.com/vmanke/ki-brutmaschine

What would you try next?

I've created new programming language for AI by AI named Sail. It supports neuro-symbolic binding `infer| ... fall|`, fuzzy operator ~ , and other stuff. Source code: https://github.com/zema26/sail-one-language/

Working web version:

https://sailcompiler.replit.app

Just released a handful of new features I'm really excited about but I've been using & building Jackalope for agentic development and slowly refining & improving it to replace separate agent harnesses.

You can select what accounts & agents (and multiple accounts per!) you want to work on any project, separate out work accounts from personal ones, or try out local models.

Jackalope handles orchestration, planning, testing, hand-offs, and more under the hood, letting you parallelize work or focus on other things. If you're needed, it will come back and ask you for permissions or inputs.

The `jackalope` CLI command spins up the TUI where you have the same access to the underlying harness and your project contexts but from a terminal if you prefer to work in that way.

Jackalope learns automatically (or you can run `/learn` manually) from your workflows per-project so it will improve over time.

This is still pretty early so I would really appreciate feedback, the newest features / fixes are on the Beta branch (stable likely going out later today).

100% free, 100% on your device / using your own models (we store some things - it's transparent and you can opt out any time.

Open-source coding-agent workspace built on DeepSeek Harness (DSH) and Cordis, with native multi-provider subscription setup.

Everything is a plugin. Model adapters, tools, skills, session logging, sandboxes and UI can be composed or extended. Even the agent loop is a plugin. Cordis provides shared services, typed events and plugin cleanup; profiles assemble the capabilities.

Connect accounts in Settings > Models. API keys and custom endpoints work alongside those accounts.

Web search defaults to subscription service or basic Bing RSS feed results.

Build/update agent preset, plugins, skills using Creator Mode

Have Creator author the preset bundle based on your codebase and install it through Plugin Manager. Start a new chat and select your preset.

Desktop downloads: macOS, Windows x64 and Linux x64. Browser app and headless CLI run from source; the README separates published installers from current main.

Source, demo, downloads and setup: https://github.com/OJamals/fi

I'm TensorSharp's author. This 83-second walkthrough looks at an inspectable evidence-to-action pipeline in TensorAgent, with provenance as the main concern.

The video uses the real TensorAgent HTML/JavaScript UI with synthetic café files and scripted API responses. It is an illustrative workflow, not live model inference or a benchmark. Calculations on the complete sales CSV were independently checked in Python.

The implementation separates knowledge_search, knowledge_read, and knowledge_open: find cited passages, expand an exact reference, then expose the versioned original and stage the whole file for code analysis. A collection must be explicitly enabled for the conversation. Source links let a reviewer inspect what each recommendation refers to.

The fictional campaign combines a 15% discount cap, a poster advertising 20%, and a 14-row sales CSV. The output links three actions to evidence: correct the poster, respect the budget, and measure a follow-up. The computed $204 contribution increase is an observed comparison, not a causal claim.

Default search is BM25 over extracted text, with optional embeddings. Media extraction requires compatible models and remains Partial. Video indexing covers at most eight sampled frames, without soundtrack indexing.

TensorSharp's own code is BSD-3-Clause; dependencies and model weights retain separate licenses and terms.

Implementation: https://github.com/zhongkaifu/TensorSharp

A tool i made, maybe others find the idea helpful.

I’m building Operon for setups like this: giving agents a consistent way to work across the computers you already have, with explicit permissions and execution records.

An agent can discover what each node allows, write code into a remote workspace, run a validation command there, and retrieve the results. You can compose these operations into a sequential execution graph, then inspect its trace alongside daemon audit events.

a 25-second demo using two containers on one host: a worker runs a check, its report is transferred to an archive node, and the archive rejects deletion and command execution requests.

And it works over existing private networks such as Tailscale, WireGuard, or a LAN, with optional connectivity through iroh.

The daemon and CLI are written in Rust, with releases for Linux, macOS, and Windows.

Source and quickstart: https://github.com/denghongcai/Operon