Hello everyone

I want to learn to edit videos, my main focus would be learning to be able to make stuff for YouTube (Well, that and contents to serve the people like it could be guides, tutorials, etc. and stuff also along other lines) and to also be able to have this in case helping somebody out or do freelancing is needed.

I am looking forward a software that is FOSS, that doesn't limit me (i mean, professional stuff like color correcting is welcome but not really needed for the things i mainly plan to work on)

I do know Kdenlive but are there any other options i should dive into?

I'd like to know your thoughts and discuss...
Thanks :)

I'm surprised that I don't really see any talk around it, and a select few projects displaying the badge. Is it because it never truly caught on, because it's viewed as a party-pooper of sorts, or am I late to the game, and it's a fad that's passed?

For context, I really got into open source about a year ago, and we followed their recs on our project, and I found some to be a bit pedantic, but others do seem to keep you honest/disciplined.

Was worth it to have those pinned dependencies? I'd say yes. Some of the work felt forced, but at the same time you learn a lot about your toolchain in the process.

Would love to hear if anyone leaned into that, and if they gained from the overall experience, or if it was just a tedious checklist.

What I probably appreciated the most was that it forced me to slow down and think through the documentation... (I personally found that refreshing and rewarding) asides from the tests/automation, etc.

Hello,

I made an open source project called LOTI.

The idea is to have a cheap distributed way for people to create verifiable timestamps and event ordering without depending on a central service.

The way it works is participants build a hash-linked history of events, so later they can query when something happened and what happened before or after it.

I originally started working on this because I was interested in the problem of proving the history of digital events. It could be useful for things like document provenance, legal disputes, audit logs, or any situation where you want a proof of the time boundaries or the frontier l definite order of digital events according to your own clock.

It's still an early project and I'm mostly looking for feedback. The project already contains an implementation in a wisely used communication network simulator and also a real world implementation. The kernel was written by me 8 years ago, the rest is created using agentic engineering very recently.

The most interesting part, where feedback would be most valuable, is how the event chain discovery can be implemented in a fast, efficient and cheap way. The difficulty lies in the evolving nature of the network topology (neighbors come and go) and the time dependent routing during discovery for events in the past.

The project is here:

https://levy.github.io/loti

Thank you!

I’m the maintainer of Open Video Craft, an open-source desktop app for recording and editing without requiring an account or uploading footage to a cloud service.

Current features include:

• Screen, camera and audio recording

• A timeline for trimming and arranging clips

• Subtitles and video export

• macOS and Windows builds

• A local-first workflow

The project uses the OSI-approved ISC license. Source code: https://github.com/Reubencfernandes/Open-Video-Craft

The current v1.0.2 builds are available here: https://github.com/Reubencfernandes/Open-Video-Craft/releases/tag/v1.0.2

One current limitation worth disclosing: the Windows builds are not code-signed yet, so Windows may show a SmartScreen warning.

I’d especially appreciate feedback or contributions around Windows compatibility, export reliability, captioning and useful editing workflows. I’ll stay around to answer technical questions and follow up on issue reports.

Solo project I've been building: `npx licenseproof scan` reads your lockfile (npm/pnpm/yarn, v2/v3, berry, all of them) and resolves the actual license of every package in the tree, including the ones with missing or mangled metadata. Categorizes everything (permissive / weak-copyleft / strong-copyleft / unknown), flags conflicts against your project's license, and explains each flag in plain English.

Example: proprietary app that innocently pulled in ffmpeg-static:

84 packages scanned — 1 conflict, 0 review, 0 unknown

CONFLICT (1):
[email protected] — GPL-3.0-or-later
via ffmpeg-static
This package is under a strong-copyleft license (e.g. GPL/AGPL).
Distributing it as part of a closed-source product can require releasing
your own source code under the same terms. Flagged as CONFLICT for a
proprietary project.

Fully offline (no telemetry, no network calls) free tier is the whole scanner. The limitation is it's informational categorization, not legal advice. What's missing? What would make you actually use this before shipping? CI mode exists (`--fail-on conflict`), JSON output exists, Python support is in progress. Thanks!

Repository: https://github.com/looptroop-ai/LoopTroop

I’m the maker of LoopTroop, a local open-source GUI for running larger coding tickets with AI.

I built it around a problem I kept running into: context rot. When one agent conversation accumulates plans, code, logs, and failed attempts, the model gradually loses track of the task.

LoopTroop uses a slower, more structured workflow:

• An LLM Council creates and reviews the plan before implementation.
• Context Engineering gives each phase its own focused context.
• Large tickets are split into small implementation steps with acceptance criteria and validation - or beads (only parts of the bead methodology).
• Ralph Loops retry failed steps with fresh context and a short failure note.
• A Kanban-style GUI keeps the ticket state, plans, logs, diffs, and review artifacts visible.
• Human approval stays in the loop before changes are handed back to the main branch (human in the loop).

The idea is to trade some speed for more predictable work on complex tickets. For small edits, using an agent directly is probably simpler. This is aimed at tasks where planning, decomposition, retries, and review history are useful.

I’m looking for technical feedback from open-source developers, especially on:

• whether the workflow is understandable from the GUI
• whether the planning and review artifacts are useful
• where the local setup or first-run experience is confusing
• whatever anything, thanks :)

There’s also a short app presentation here:

https://youtu.be/LYiYkooc_iY

Any feedback is more than welcome. If you try the app and something works, or doesn’t,please give me a sign. Happy to talk about it.

Sharing SAIPEN — an MIT-licensed continuation protocol for AI coding agents. Whole thing is plain markdown: a spec (RFC.md), phase docs, and a project-side .saipen/ folder with three files. No runtime, no server, no package to pip install — the validator (tools/validate.py) is stdlib-only Python specifically so there's nothing to audit for supply-chain risk, with a shell-script fallback for hosts without Python at all.

Genuinely open to contributions — extension points for security/performance hooks, multi-agent coordination, per-platform adapters are all documented as copy-in examples rather than baked into core. Issues and PRs welcome, especially "this broke on my setup" reports.

Repo: [github.com/vacterro/saipen]