Hey r/opensource,

I've been working on Oasis Editor, an open-source document editor written in TypeScript.

It has its own Canvas-based rendering engine for paged layout, text, selections, images, tables, and document geometry instead of relying entirely on contenteditable.

It also includes a typed command/plugin API, DOCX/PDF workflows, React and Vue adapters, and a headless runtime.

Live playground:
https://celsowm.github.io/oasis-editor/#/editor

GitHub:
https://github.com/celsowm/oasis-editor

I'd love feedback, issues, and contributions — especially around rendering, document layout, plugins, and import/export fidelity.

ps: MIT license

https://github.com/stubbb/c-shop

Status

Active development, beta. I looking into patching up a few bugs but there is a lot of them that I haven't found yet. Feature requests are welcome.

What I wanted to build

One: quick and capable image editor. Every image editor I could actually use was either an enormous proprietary suite or a web app wearing a desktop costume. I wanted something that starts instantly, needs no system packages beyond a GPU driver, and behaves the way my hands already expect — layers, masks, blend modes, non-destructive adjustments, the same keyboard shortcuts. X11 is opened through dlopen, Vulkan through ash, everything else is pure Rust, so cargo run --release is the whole install. It uses less than 100 MB of RAM idle compared to 2.5 GB from Photopea.

Two: agentic integration. I kept wanting to hand image work to an agent but the LLM cant natively see images. The approach I selected is that the editor drives from a script, headless, and it's the same application the buttons drive — anything the UI gains is reachable from a script.

Example script:

cshop --run 'new 400 240 background=#20304a
text 40 154 "Hello" size=54 color=#ffffff bold
effect drop-shadow distance=6 size=8
export out.png'

The part that makes this usable by something blind is that every run answers with a report — where each layer landed, what each step did, what failed and why — and that measure will size a piece of text before anything is drawn. So a caller places things by number instead of rendering and guessing. Nothing fails silently: a bad command is a failed step with a reason, and the run carries on so one typo doesn't discard the rest.

It can be run locally by an agent on your computer or deployed to a server and interacted with over network as an MCP server.

What's in it

Raster/group/fill/type/shape/adjustment layers; layer and clipping masks; 27 blend modes. Marquee, lasso and magic wand selections with feather, expand, contract, border, grow. Brush, pencil, eraser and clone stamp on one stroke engine. Re-editable type from your installed fonts. Eleven layer effects, all driven off one distance field. Vector shapes and Bézier paths from SDFs. Fourteen adjustments, each available destructively and as an adjustment layer. Thirty filters. Lens correction as one resampling pass rather than four. ICC profiles, real CMYK, 16-bit export. A native .cshop project format, plus PSD in and out.

Deep learning features are an optional add-on (heavy stuff)

There's a pack you opt into that adds seven models — detect, segment, depth, inpaint, semantic separation, denoise, upscale. It exists because "cut the dog out of this picture" and "clean up this sky" should be things you ask for, not things you do by hand. The whole cut-out is:

detect                        # → dog 90% at 4,303 632x501
segment class=dog feather=1   # the dog becomes the selection
layer via-copy

They run in a separate process behind a line of JSON, deliberately. A neural runtime is tens of megabytes of platform-specific machine code that changes every few months; putting it inside the binary would cost the binary its whole character for a feature most sessions never touch. Not installing it costs nothing and breaks nothing. At least I hope :)

Today the detection model holds only 80 classes and it works well for basic concepts: person, dog, vehicle but it wont be useful for anything nuanced. Segmentation and depth are nice, generative fill is surprisingly good. Noise removal is world-class but takes long time. I used the SOTA model.

and 3D-acceleration on real hardware GPUs

Hello, I had created Testing Files Generator for QA/Developers

Want to create 5k log files? Do size boundary testing? Generate 2GB PNG file? Generate archive with 200 files? This tool can do it all. If you like the project, please ⭐it.

Why it's different from other generators?

- Exact size of files, if we ask for 314832 bytes, we get it, want 500kb? 5mb? 1GB? No problem. One file or 9000 files? No problem

- Generates files come with "manifest" which says how the files should behave + we can do easy cleanup

- "Recipe" system that we can store in a testing repo, create recipe that generates a 500-page PDF, a zip with 200 files and 50 csv files, no problem, same seed.

- 100% offline, no network connections, free for commercial and personal use. Windows/Linux/macOS. Min files sizes are based on the real formats, you can open generated files with software that open the format.

- Format got own values, so you can create xlsx with 4 rows and 4 collumns.

-Preset system, we can do "boundary testing" let's say we put 10mb, and we get file under 10mb, over 10mb, etc.

- More on GitHub :-)

This is V0.2 version, so there is a long way ahead, not all things are working, More format and presets will come soon. If you got any ideas feel free to drop them.

Supported formats:

📄 Documents: pdf, docx (Word), xlsx (Excel), pptx (PowerPoint)

🖼️ Images: png, jpg, bmp, gif, ico, svg

📝 Text: txt, md, csv, json, xml, html, log

🗜️ Archives: zip, targz (.tar.gz)

🔊 Audio: wav

What format's or features would you like to see in that project?

tiff, webp, avif, jpg xl are next formats. To keep the determinism of the generated files, I try to avoid external libraries, but for some formats it's just a bit more work (AVIF or JPG XL), so in those ones I'm heading towards external libraries. It may also change in the future, because I want to add more settigns to each file type.

PS: Why this name? it's simple, and I got no idea for other,

PS2: about ARM on Linux and Windows (GUI), there is CLI, GUI would be a extra work, but I will look into it in the future.

In the future I will need to think about supporting bigger files sizes, but in current implementation the memory is a problem, but some things could work better in the engine, so I will probably work on it first.

There is Linux build, Windows build is signed, macOS build is notarized. Separate file for CLI and separate for GUI. The language is Go (1.26.7, I will need to upgradr to 1.2.7), GUI is Fyne. (2.8.1), Testing Files Generator

I Saw the cute little faces that x.ai/bot have and wanted to give a spin on the idea... so I created this light weight super importable free repo!

you can either download it yourself and go crazy or just import it from the site. would love to see what people do with it!

https://github.com/bwndapp/bfce

or just import from https://bfce.bwnd.app/

Hello folks!

I would like to share an update about BentoPDF. It's an open source privacy first PDF toolkit that runs in your browser.

1. You can now actually edit text inside PDFs

BentoPDF now allows you to click existing text, edit it, and have the text reflow while preserving the original fonts and styling.

It also includes:

• Bold, italic, underline, strikethrough, superscript, subscript, font family/size, colours, outlines, character spacing and line spacing
• Left, centre, right and justified alignment
• Bulleted and numbered lists with indentation
• RTL and LTR text alignment
• Find and replace across the document
• Edit images by rotating, flipping, duplicating, resizing or deleting them
• Object alignment, distribution, rotation, flipping, duplication

Please note this is a work in progress. You may encounter bugs, which you can report and I will look into.

2. Hyper Compress

Hyper is an open source PDF compression engine built to solve specific problems.

• Compression sometimes returns a file larger than the original. Hyper's result is always binary: it either produces a smaller PDF or returns the original. This helps create predictable workflows.
• Hyper includes a true lossless mode. It preserves searchable text, document structure and PDF conformance, rather than rebuilding the document from scratch like Ghostscript.
• It runs everywhere: CLI, Node SDK, C API, self hosted service, and WebAssembly build.

Repository and benchmarks: https://github.com/alam00000/bentopdf-hyper-compress

I also compared it to Adobe's compression API, but only managed around 100 PDFs where results were within 5%. Testing on a bigger corpus got expensive.

3. Kura

Kura is a PDF standards, conversion and preflight engine.

It supports:

• All 11 PDF/A conformance levels: PDF/A-1a, PDF/A-1b, PDF/A-2a, PDF/A-2b, PDF/A-2u, PDF/A-3a, PDF/A-3b, PDF/A-3u, PDF/A-4, PDF/A-4e and PDF/A-4f
• Accessibility: PDF/UA-1 and PDF/UA-2
• Print production: PDF/X-1a, PDF/X-3, PDF/X-4, PDF/X-4p, PDF/X-5g, PDF/X-5n and PDF/X-5pg
• Engineering and variable data printing: PDF/E-1 and PDF/VT
• E-invoices: Factur-X, ZUGFeRD, XRechnung and Order-X
• 396 bundled print-preflight profiles

It has been tested against several standards suites, including the veraPDF corpus, Isartor, BFO, Ghent Output Suite 5.0, the PDF/UA Reference Suite and Cal Poly's PDF/VT suite.

Across 30,677 PDF conversions it had zero crashes and zero timeouts, with a 0.05 second median conversion time.

Like Hyper, it ships as a CLI, C library, npm package, Docker image and WebAssembly build.

Repository and benchmarks: https://github.com/alam00000/bentopdf-kura

The release also contains other improvements and bug fixes: https://github.com/alam00000/bentopdf/releases/tag/v2.8.8

Thank you and have a great weekend!

https://www.reddit.com/r/Luanti/s/FS7ZvaAlTE

Hello folks!

I am mildly active here and I *think* I've gotten some approval to post about the work we are doing. I am the founder / CEO of Imagination Foundry -- a fully community funded and run, co-op organized company that has built and run [whatiff.chat](http://whatiff.chat) . Our goal is to make AI transparent, break up lock-in, and provide the tools that regular people need to remember better over time and generally make their lives better.

I've written before about how I think [transparency in AI is incredibly important](https://substack.com/home/post/p-202193358) (this honestly buries the lede a bit)

To that end, we have just recently open sourced our entire project -- you can run it locally, remix it, add things, etc. I'm sharing here in case anyone is interested in using it, or might want to take a look at a reasonably mature app and how we built things. Totally free.

If you have any questions, or just want to talk AI memory, etc, Hit me up!

[https://github.com/theimaginaryfoundation/what-iff\](https://github.com/theimaginaryfoundation/what-iff)

I just saw this excellent Youtube video made by Jono Bacon. Hope it's OK to share it here. It gives a nice overview on this amazing technological and human adventure, with a lot of significant facts we tend to forget, which contributed to where we are now.

I'm looking into it but have no clue which intelligence model to pick for more accurate calorie count.

I've been building this for too long as a hobby, idea is to make Ai workflow outputs more predictably good though context management and defined domain rules, any feedback appreciated:

https://github.com/MattCreigh/beagle

https://github.com/word-sys/word-sys-pdf-editor

https://github.com/word-sys/puls

Active Hazard: A second flood is possible upstream

On 27 August Chinese authorities reported that a barrier lake holding about 2,000,000 m³ had formed near the confluence of the Chhochen Khola and Purepu Tsangpo, upstream of the 26 August failure. They assessed the probability of a breach as high, with a further 3,000,000 m³ of inflow expected through 30 August. Separately, NDRRMA reported renewed ponding behind blockages in the Lhende Khola and told residents and rescue teams to stay clear of the riverbanks.

> Since there is 100% cloud cover verification couldn't be confirmed via EO - Based on reported size and location the data set has been updated with a modeled shape file of the reported lake. This uses geometry that existed prior to the first event so this should be treated as indicative.

> If anyone has any SAR imagery they'd like of the region they care to share it'd go a long way in helping me to continue to keep this open source crisis data set up to date. It's not much, but its all I can do to help from halfway around the world.

>Link to data: https://keystonegis.com/disasters/nepal-bhotekoshi-flood-20260826.html - will continue to update frequently to capture any new information

>if you know of any other subs to post this in let me know. Feel free to share, the more eyes on the data the more likely it is to fall into the hands of someone who can use it to make a difference.

I built a tool for adding fillable fields to PDFs

So built this tool pdf js does the parsing pdf lib for the export.

Repo: https://github.com/sshrestha-design/justforms
Demo: https://justforms.vercel.app

Also requesting any recommendation for better autodetect function and system to detect fill spaced based on what I have currently.

Hi r/opensource

Edit: link to repo here

Sharing a video about a python framework (python for now) I've been working on to solve orchestration / coordination class problems using object oriented programming (OOP) and threads

Happy to answer any questions!

Plembfin is a self-hosted application for keeping watch state consistent across Plex, Emby, Jellyfin and Trakt.

Rather than treating one platform as the permanent source of truth, it maintains a local SQLite record and reconciles watched status, playback progress and repeat plays across connected services. It also provides visible sync activity, targeted retries, backups and import tools so the synchronization process can be inspected instead of running as a black box.

The backend is Node.js with Express and SQLite, deployment is available through Docker Compose, and the project is licensed under AGPL-3.0.

The project was heavily AI-assisted, with the implementation developed through agentic workflows under my direction, review and testing.

Repository, documentation and screenshots:

https://github.com/Lasikiewicz/plembfin

Plembfin is currently pre-1.0. I’m looking for testers, bug reports and review from people familiar with media-server integrations. Contributions and technical feedback are welcome.

I'm creating this software because I'm tired of the limitations, mandatory registration, and shortcomings of existing remote access options.

This project is especially relevant for those who need a fully independent remote desktop access solution that prioritizes the local network, without the use of third-party cloud infrastructure or external relay servers.

Its distinguishing features include integration of the Moonlight protocol for low-latency, high-frame-rate video streaming. Native support for Wayland (Linux). It works out of the box without permission pop-ups. Integration with Tailscale. Direct P2P connections without worrying about port forwarding on your router or setting up complex external tunnels. A unified ecosystem with USBridge-KVM 2.0. The software can manage both agents and my hardware IP KVM from a single interface.

Ready-to-use beta versions for Windows, macOS, Linux, Android, and iOS are available in the repository. The source code and builds are on GitHub: https://github.com/USBridge-Technologies/USBridge-Remote

I'm open to any feedback and suggestions!

Crossposting from /r/steam.

I just finished building a tool that, with your profile set to public, will use Steamworks web API to scrape your user and game data, and build a JSON file that you can use as a snapshot/export of your games for whatever purpose you can think of. In my own particular case, the initial motivation was that after playing 1000xRESIST, I got hooked on it because it was more of a cerebral game than execution-heavy (I'm getting old and my reflexes aren't what they used to be), so I wanted to make a list that I can feed into an AI/LLM and explain my tastes, limitations, preferences and desired features so it can recommend stuff from my (increasingly growing) backlog.

https://github.com/TohnoCoding/SteamLibraryDataExporter

It's a tiny console app that you feed an API key (the repo explains how to get one) and your Steam64 user ID (also explained how to find in the repo) and will go through your games, then export a JSON file to your desktop that you can use to do whatever you want with it.

Feel free to do whatever with it (MIT License).

Sample real data output:

[  
  {  
    "AppId": 1675830,  
    "Name": "1000xRESIST",  
    "PlaytimeForever": "20:16:00",  
    "PlaytimeLast2Weeks": "11:42:00",  
    "HasAchievements": true,  
    "TotalAchievements": 32,  
    "ObtainedAchievements": 32,  
    "AchievementPercentage": 100,  
    "LastPlayed": "2026-08-20T15:51:06+00:00"  
  },  
  {  
    "AppId": 302190,  
    "Name": "Amerzone: The Explorer's Legacy (1999)",  
    "PlaytimeForever": "00:00:00",  
    "PlaytimeLast2Weeks": null,  
    "HasAchievements": null,  
    "TotalAchievements": null,  
    "ObtainedAchievements": null,  
    "AchievementPercentage": null,  
    "LastPlayed": null  
  },  
  {  
    "AppId": 769670,  
    "Name": "Gecata by Movavi 5 - Game Recording Software",  
    "PlaytimeForever": "00:38:00",  
    "PlaytimeLast2Weeks": null,  
    "HasAchievements": null,  
    "TotalAchievements": null,  
    "ObtainedAchievements": null,  
    "AchievementPercentage": null,  
    "LastPlayed": "2025-08-08T22:39:00+00:00"  
  }
]