r/react

Over the past few months I've been building an open-source desktop application called Limboo, and I wanted to share the idea behind it because I'm curious whether anyone else has been running into the same problems.

One thing I've noticed with AI coding tools is that they're incredibly good at writing code, but once a project becomes large, the actual engineering workflow still feels fragmented.

The AI is usually in one window.

Git is somewhere else.

The terminal is somewhere else.

Build logs are somewhere else.

Documentation is in another browser tab.

Project decisions are spread across old conversations.

The longer I work on something, the more time I spend rebuilding context instead of actually building software.

That observation is what started Limboo.

The goal isn't to replace coding agents like Claude Code, Codex, or other agent-based tools.

I actually want to use those.

The idea is to build everything around them.

Instead of treating the AI as the entire application, Limboo treats it as one component inside a much larger engineering workspace.

Every task becomes its own isolated session.

Each session has its own conversation history, terminal state, Git branch or worktree, checkpoints, permissions, local memory, search index, execution timeline, and task list.

If I stop working on a feature today and come back in two weeks, I don't want to explain everything again.

I want to reopen the session and continue exactly where I left off.

Another thing I wanted to improve is transparency.

I don't like when an agent runs commands that disappear into a log somewhere.

If it's running a build, I want to watch the build.

If it's modifying files, I want to see the diffs while it's working.

If it wants approval, I don't want a giant modal that interrupts everything—I want approvals to appear naturally inside the conversation stream.

Planning is another area I'm spending a lot of time on.

Instead of generating a plan that disappears after one response, the plan becomes a living task board.

Once it's approved, the agent starts implementing those tasks while updating their progress in real time.

Git is also treated as a first-class part of the workflow instead of an afterthought.

Every change is visible through diffs, checkpoints, snapshots, commit previews, and history before anything gets committed.

The goal is to make it obvious what changed, why it changed, and which conversation produced those changes.

I'm also experimenting with isolated Git worktrees so multiple sessions can work on completely different features without stepping on each other.

Another area I'm investing in is local memory.

Rather than asking the agent to rediscover architecture decisions, coding conventions, and previous implementations every session, the application stores that knowledge locally and retrieves only what's relevant before each request.

Everything is designed around long-running software projects instead of one-off prompts.

The stack is Electron on the desktop, Rust for native services, and AI agents orchestrated through the Claude Agent SDK.

It's still very much a work in progress, and I'm sure there are plenty of design decisions I'll end up changing as I build more of it.

I'd genuinely appreciate feedback from people who use AI coding tools every day.

I'm especially interested in hearing what parts of your workflow still feel disconnected, because that's really the problem I'm trying to solve.

Repository: https://github.com/BotCoder254/limboo

I'd love to hear what you think—both the good and the bad.

Today I learned:

- Form Handling

- State Lifting Up

- Conditional Rendering

- Single Way vs Two Way Binding

- Creating UI from Figma designs using Tailwind CSS

Built a simple Login/Register switch using:

Domternal is an open-source (MIT) rich text editor built on ProseMirror, with first-class Angular components.

The clip shows one editor core as two surfaces: a Notion-style block editor and a classic toolbar editor.

The Angular part ("@domternal/angular")

- 6 standalone components (no NgModule): editor, toolbar, bubble menu, floating menu, emoji picker, Notion color picker
- Signals-driven, OnPush, zoneless-ready (the demo runs on zoneless Angular 21)
- The editor is a ControlValueAccessor, so it drops straight into ngModel or a reactive FormControl; outputFormat="json" emits JSON
- Toolbar and menus auto-render from whatever extensions you load, so there is no manual button wiring
- Works from Angular 17.1 through 21

Features

Notion-style blocks (drag handle, slash menu, smart paste, floating table of contents), tables, LaTeX math, images, @mentions, emoji, collapsible details, syntax-highlighted code blocks. 126 chainable commands, 70+ nodes, marks and extensions, all tree-shakeable. Light and dark theme via 160+ CSS variables. getHTML({ styled: true }) inlines the CSS so exported content still renders in an email client or a CMS.

Under the hood

Built on ProseMirror, strict TypeScript throughout. About 117 KB gzipped including ProseMirror. The same Playwright e2e suite runs green across all four framework wrappers, on top of 4,400+ unit tests.

It is MIT and currently at v0.11.2. I would love your feedback.

Site: https://domternal.dev
GitHub: https://github.com/domternal/domternal

Hey folks,

I wanted to share a side project I've been working on called ExamBuddy.

The Problem:
During competitive exams, a lot of students get assigned centers that are far away from their homes. Traveling alone is expensive and sometimes unsafe, and coordinating transport is a hassle.

The Solution:
I built a platform where students can find others who are traveling to the same exam center or nearby areas. It allows them to connect, pool resources for cabs/buses, and share travel plans.

Tech Stack I Used:

• Frontend: React (Vite) + Tailwind CSS for styling.
• Backend/Auth: Firebase Authentication (Google Sign-in).
• Database: Firestore for storing user profiles and real-time travel coordination.
• Hosting: Google Cloud Run (currently in preview).

Challenges I faced:
Initially, I struggled with deciding between Vercel and Firebase for hosting, but eventually leaned towards Firebase/Cloud Run because it integrated seamlessly with my database and Auth setup. I also learned a lot about structuring real-time data for chat and coordination.

I'm looking for feedback on the UI/UX and any suggestions on what features I could add next!

If you want to check it out, the live preview link is here: https://exam-buddy-app-dywc.vercel.app/

(Any feedback on the codebase or architecture is highly appreciated!)

Hi! I’m the dev behind PostSpark, a tool for creating beautiful image and video mockups of your apps and websites.

I recently launched a new feature: Mockup Animations.

You can now select from 25+ devices, add keyframes on a simple timeline, and export a polished video showcasing your product. It’s built to be a fast, easy alternative to complex motion design tools.

Try it out here: https://postspark.app/device-mockup

I’d love to hear your feedback!

Hi! I’m the dev behind PostSpark, a tool for creating beautiful image and video mockups of your apps and websites.

I recently launched a new feature: Mockup Animations.

You can now select from 25+ frames & devices, add keyframes on a simple timeline, and export a polished video showcasing your product. It’s built to be a fast, easy alternative to complex motion design tools.

Try it out here: https://postspark.app/templates

I’d love to hear your feedback!

import { RefObject } from "react";
import gsap from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";
import { useGSAP } from "@gsap/react";


gsap.registerPlugin(ScrollTrigger);


type HeroAnimationRefs = {
  heroSectionRef: RefObject<HTMLElement | null>;
  heroTextRef: RefObject<HTMLDivElement | null>;
  floatingImageRef: RefObject<HTMLDivElement | null>;
  storyTargetRef: RefObject<HTMLDivElement | null>;
};


export default function useHeroAnimation({
  heroSectionRef,
  heroTextRef,
  floatingImageRef,
  storyTargetRef,
}: HeroAnimationRefs) {
  useGSAP(() => {
    if (
      !heroSectionRef.current ||
      !heroTextRef.current ||
      !floatingImageRef.current ||
      !storyTargetRef.current
    ) {
      return;
    }


    const imageRect = floatingImageRef.current.getBoundingClientRect();
    const targetRect = storyTargetRef.current.getBoundingClientRect();


    const imageCenterX = imageRect.left + imageRect.width / 2;
    const imageCenterY = imageRect.top + imageRect.height / 2;


    const targetCenterX = targetRect.left + targetRect.width / 2;
    const targetCenterY = targetRect.top + targetRect.height / 2;


    const x = targetCenterX - imageCenterX;
    const y = targetCenterY - imageCenterY;


    const scale = Math.min(
      targetRect.width / imageRect.width,
      targetRect.height / imageRect.height,
    );


    const tl = gsap.timeline({
      scrollTrigger: {
        trigger: heroSectionRef.current,
        start: "top top",
        end: "bottom top",
        // pin: true,
        scrub: 1,
        markers: true,
        invalidateOnRefresh: true,
      },
    });


    tl.to(
      heroTextRef.current,
      {
        opacity: 0,
        y: -250,
        ease: "none",
      },
      0,
    );


    tl.to(
      floatingImageRef.current,
      {
        x,
        y,
        // scale,
        transformOrigin: "center center",
        ease: "none",
      },
      0,
    );


    ScrollTrigger.refresh();
  });
}

I'm trying to animate the hero image so that it moves into the red box while scrolling. I calculated the distance using getBoundingClientRect(), but the result isn't what I expected. Could someone point out what I'm doing wrong? Here's my code:

Thought it would be cool to add a self-drawing SVG animation to my portfolio, but it took some time to figure out. anime.js has this feature, but getting it to work properly and converting an image into a clean SVG paths (with the right threshold and other settings) may take some time. So I built a tool for it.

You drop in a photo or logo -> it converts it into SVG paths -> animates those paths(they draw themselves like a pen sketch)

features/how to use

• upload an image and it converts into single-color SVG line art
• choose custom path and background colors
• adjust the trace settings: threshold(usually 100 works best), invert dark/light
• control the animation: duration(in ms), delay between paths, easing, direction (forward/reverse/ping-pong), looping, fade-in fill at the end
• Export as copy-paste SVG, a downloadable SVG file, or a self-contained HTML file with everything included

Works best with illustrations, cartoons, and clean line drawings. Real-world photos can be harder to convert into clear SVG paths

Links:

• Repo: https://github.com/a1stok/img2svg-animation
• Live demo: https://img2svg-animation.vercel.app/

Open to feedback or suggestions if you have any

Hi all,

I’ve been working on AltSendme for the past 8 months, a free and open-source file transfer app built around one simple idea: file transfer doesn’t need to be complicated.

Instead of uploading your files to cloud storage first, AltSendme uses peer-to-peer transfer powered by Iroh. You drop a file or folder, AltSendme creates a one-time share ticket, and the receiver pastes that ticket to start the transfer.

Available as cross-platform desktop applications, Android and CLI.

Some of the main features:

- Peer-to-peer direct transfers, with no cloud storage in the middle

- End-to-end encryption using QUIC + TLS 1.3

- No accounts or personal info required

- Send files or folders of any size or format

- Resumable transfers if a download gets interrupted

- Broadcast mode to share the same file/folder with multiple peers

- Preview before downloading

- Fast transfers, including support for multi-gigabit connections

- NAT traversal with encrypted relay fallback (Self-host Iroh relays)

- Free and open source

I’m sharing it here because I’d love feedback from other web/dev folks, and I’m also looking for contributors.

GitHub: https://github.com/tonyantony300/alt-sendme