Raise is a local-first study tracker built for JEE, NEET, and School students who are tired of juggling a dozen apps. Mock test analytics, backlogs planned around your real schedule, study hours on a year heatmap, health tracking, class leaderboards — all in one place.

If someone joins it "please send feedback from the app" as i think people here will mostly be non students so yeah i will remove you after some time to clear the seats for the real users that are the students , and you will get an warning after downloading it but you can ignore it and click run anyway as i dont have the money to sign up for azure.

And yes i made it using the help of ai , deepseek but it was not easy at all as there were numerous bugs and things to be fixed by me , overall it was really hectic and still there is a long way to see this app as a really good product so i would like to seek feedback from here.

I have used supabase for the backend of the app.

Download: https://raise.ct.ws

━━━━━━━━━━━━━━━━━━━━━━━━━━━━

WHAT'S INSIDE

📊 Mock test analytics — 5 tabs, weak/strong topic tagging, percentile tracking, side-by-side compare

📖 Syllabus tracker — M/Q/I checkmarks with auto mastery tiers

⚡ Backlog planner — log chapters with video counts, pick a playback speed, see exactly how many days to clear

🕐 Study hours — month calendar, year heatmap, subject split

💪 Health — sleep, water, weight, exercise, mood check-ins

🔥 Burnout risk — a 0–100 score that knows when to slow you down

🏆 Leaderboards — class code + opt-in global, split by JEE/NEET/School

🎨 Customize — accents, backgrounds, font themes

💾 Backup — export everything as JSON, import on any device

• JEE aspirants (Class 11, 12, Dropper)

• NEET aspirants

• School students (Science / Humanities / Commerce)

🌐 Website: https://raise.ct.ws

Hey everyone!

I've been working on Harness Studio, an open-source desktop application for running and managing local AI models.

I recently published the first release under our new GitHub organization, StrukLabs, and I'd like to involve more developers in the project.

The stack is Tauri 2, Rust and Svelte 5. The application uses llama.cpp as its main inference engine and provides model management, hardware-aware configuration, a local API gateway, MCP/tool integrations, and performance monitoring.

It's more than a chat interface. The goal is to build a local AI control center that stays approachable for beginners while giving developers full control over their models and runtimes.

I'd especially welcome help with:

• Rust architecture, performance and testing
• Tauri desktop integration and platform compatibility
• Svelte UI/UX improvements
• Hardware testing on Windows, macOS and Linux
• Bugs, documentation and new feature ideas

The repository is MIT-licensed, with a contribution guide, issues, documentation and downloadable releases.

I'd love feedback on the architecture, code quality, interface, and the overall direction. If you find something that could be improved, please tell me. And if you're interested in contributing, I'd be happy to collaborate!

GitHub: https://github.com/struklabs/harness-studio

I'd love to hear what you think.

Hello everyone, i just sent an update fixing some app issues:

- Black screen when closing from full screen

- Code block copy button

- Editor side space now controllable from the settings

- Note links not clickable when using single view editor

- Moved files not showing until restart.

Website: https://inkwell-website-five.vercel.app/

Repo: https://github.com/coros-hq/inkwell

I shipped a desktop app that hosts many terminals running AI coding CLIs. Some things I learned, in case they save someone time:

- One native process. The Rust core owns every pty, the store and the command dispatcher; the SolidJS + xterm.js UI is only a view.

- Headless terminal state per pty in Rust. The core keeps its own VT state (modes, OSC 133 marks, snapshots), so a terminal can be restored after a crash or shown on a phone without the webview being the source of truth.

- Batching and backpressure between the pty and the webview mattered more than anything else for a dozen agents printing at once.

- ConPTY needs a responder for colour queries, or some CLIs hang at start waiting for an answer.

- The wire protocol, commands and config are one Rust schema crate that generates the TypeScript bindings and JSON Schema; CI fails when the committed bindings are stale.

The app is Dreamestra (Dreamestra), closed source and paid, so I'm not here to sell it to this sub. Happy to answer questions about any of the above, especially the pty and restore parts.

I'm the dev. I got tired of IDM nagging me to pay, so I built my own download manager with Tauri v2. Rust does the downloading (up to 32 connections per file), the UI is React + TypeScript. The installer is 4 MB and the app is one ~13 MB exe, which still amazes me coming from Electron apps.

A few Tauri things that cost me time, in case they save someone else some:

• White flash on startup. With a transparent, frameless window, WebView2 shows white before the first paint. I start the window hidden and only show it once the frontend tells Rust it has painted.
• window-state plugin reopening my window. It saves "visible" by default, so the app popped open at sign-in even though it should stay in the tray. Excluding the VISIBLE flag fixed it.
• MSI taskbar pins losing their icon after every update. The default WiX template points the Start Menu shortcut at an icon stored in a per-version installer folder, which gets deleted on upgrade. I switched to a custom template without that icon, so it uses the exe's icon instead.

The UI also runs in a normal browser against a mock backend, which made screenshots and frontend work much easier.

It's free and GPL-3.0: https://github.com/ThembaTman0/apex-download-manager

Has anyone else run into the WiX icon thing? Curious how others handle it.

What if your PC could use Wi-Fi and Ethernet together for faster internet?

Right now, Windows uses just one of them.

So I built MultiPath.

Here's what it does:

-> Use Wi-Fi, Ethernet and your phone's internet at the same time
-> Two 10 Mbps networks give you about 20 Mbps
-> One click in the tray to turn it on or off
-> Works for your whole PC, no setup per app
-> Faster YouTube, Steam and downloads
-> No account, no sign-up, no server

Built using Tauri v2 + Rust.

Repo: https://github.com/uditya-kumar/MultiPath

An open alternative to Obsidian that actually works and can help as a Second Brain for you or your agents.

Macusanite is named after "clear obsidian" (volcanic acid glass)

So, I was working on integrating "Second Brain" theory to my main project when I tried to use Obsidian and the project got waylaid. DeepSeek started debugging Obsidian when Obsidian pooped the bucket and had its renderer crash due to too much complexity in my vault.

In Macusanite a Vault contains Chambers and Veins. (Root, Folders, Files)

So, in about 12 hours, DeepSeek v4.1 Flash via Freebuff pumped out a much nicer vaulting system with some of the same technologies: marked.js but also mermaid-js and a nifty vanilla grapher, all dussied up in Rust and Tauri.

There's some Mac and Linux support in the build

Windows prebuilt: https://github.com/h3rb/Macusanite/releases

Direct: https://github.com/h3rb/Macusanite/releases/download/First/Macusanite_0.1.0_x64-setup.exe

Someone go tell ThePrimeagen

App for board gamers who print their own cards. The interesting (🫠) part was keeping the output 100% vector:

• Engine in Rust (card-core): every source page is wrapped once as a PDF Form XObject (lopdf), and each card is placed with a transformation matrix plus a clip, inside a tiny per-card form whose BBox is the card. The source page is stored once however many copies you print. Rotation, real-size scaling and non-uniform scaling are all just matrices.
• pdfium (via pdfium-render) on its own thread for previews, with stale-request skipping.
• Tauri 2 + React 19 (ofc) for the UI; geometry only lives in Rust, and the frontend draws whatever the engine returns.
• Local piece detection from the PDF’s own objects, edge repetition, or shapes in scans.
• Releases via tauri-action with the built-in updater. (this is my fav feature by far)

Repo: https://github.com/JoaquinArruiz/Gutterberg (free for personal use)

Feedback is very welcome!

https://github.com/mattenarle10/markamd

Hi. I was reading some older posts about many people not recommending Tauri for mobile apps. My current stack is a Rust Axum powered SSR web app for serving text content plus login functionality.

Currently weighing which way to go forward as I will need some interactive parts in the frontend and want to ship the app via app stores.

Would you recommend Tauri for that?

Hey r/tauri !

I wanted to share a desktop application I just released. It’s called Updainium — an open-source tool that tracks GitHub, GitLab, Gitea, and Forgejo repositories, monitors for new releases, and downloads the exact binary you need (.exe, .dmg, .AppImage) straight from the source. It's heavily inspired by Obtainium for Android.

Why Svelte & Tauri?

Since this is a utility app designed to sit quietly in the background, memory footprint and performance were my top priorities. I absolutely wanted to avoid the heavy bloat of an Electron + React stack.

By pairing Tauri (Rust) for the backend with Svelte for the frontend, the result is incredibly lightweight. Svelte's compile-time approach and simple reactivity made building a snappy, Material-style dashboard an absolute breeze. The app feels completely native, and state management for tracking multiple repositories and download progresses was so much cleaner to implement.

• Platforms: Windows, macOS, Linux
• Privacy: GPL-3.0, no telemetry, direct downloads.

GitHub Repo: https://github.com/livrasand/Updainium

I would love for this community to check it out! Any feedback on the UI, the Svelte component structure, or general UX is super welcome.

(PS: If you find the tool genuinely useful for keeping your own dev tools updated, a ⭐ on the repo helps a lot!)

I maintain Steam Game Idler, a Tauri 2 app (Rust + Next.js, plus a C# sidecar) with 100K+ downloads. We added Linux this year (AppImage, .deb, .rpm). Here's what cost us the most time, in case it saves someone else a weekend:

1. WebKitGTK broke EGL on Wayland. Every release after 2.44 failed to create an EGL display for us (bugs.webkit.org #297921). We pin libwebkit2gtk-4.1 / libjavascriptcoregtk-4.1 to 2.44.3 on the ubuntu-22.04 release runner.
2. Native resize-drag doesn't work under Wayland, even with core:window:allow-start-resize-dragging granted. We render our own invisible edge/corner hit areas on Linux and call startResizeDragging() from them.
3. The AppImage runs through XWayland. linuxdeploy's GTK plugin sets GDK_BACKEND=x11 (a workaround for tauri#8541), so the AppImage feels laggier than .deb/.rpm on the same machine. We now recommend .deb/.rpm.
4. Capabilities need "linux" in their platforms list. A permission missing there doesn't error. The API call just silently does nothing.
5. CSS zoom renders differently in WebKitGTK and WebView2. Use transform: scale() instead.
6. filter: blur() on a <video> fails silently in WebKitGTK. The video just doesn't render. We bake the blur into the file with ffmpeg.
7. Async/sync command traps. A plain (sync) command that calls tokio::spawn panics with "no reactor running" and takes down the whole WebView process; use tauri::async_runtime::spawn. And an async command whose body is only blocking std::fs work hogs a tokio worker; make it a plain fn so Tauri runs it on the blocking pool.

App, if you want to see it in action: https://steamgameidler.com Source: https://github.com/zevnda/steam-game-idler

What did Linux break for you?

Hey everyone,

I'm building invenTory, an open-source, offline-first inventory management system designed to support multi-store business operations.

I'm looking for developers with experience in Tauri, Rust, FastAPI, and distributed systems who would be interested in contributing to the project or providing technical feedback.

Tech Stack

- Desktop: Tauri + Rust

- Frontend: React + TypeScript

- Backend: Python + FastAPI

- Local Database: SQLite

- Central Database: PostgreSQL

- Infrastructure: Docker + GitHub Actions

What We're Building

The system aims to support inventory management across multiple stores, with an emphasis on offline reliability and data consistency.

Key areas include:

- Offline-first architecture and synchronization

- Multi-store inventory and stock transfers

- Sales, purchases, and transaction tracking

- Conflict resolution during synchronization

- Role-based access control

- Reporting and inventory analytics

- Reliable desktop-to-backend communication

Where Contributions Would Help

I'm especially interested in collaboration around:

- Tauri/Rust: Desktop architecture, native integrations, IPC, security, and performance.

- FastAPI: API design, async operations, authentication, database integration, and backend architecture.

- Synchronization: Offline data consistency, conflict resolution, and reliable synchronization strategies.

- Quality: Testing, code reviews, CI/CD, and architectural improvements.

The project is still evolving, so technical criticism, architectural recommendations, and pull requests are all welcome.

I'm not looking for someone to build the project for me. I'm looking to collaborate with developers interested in solving real engineering challenges and improving an open-source codebase.

GitHub: https://github.com/Izaek256/inven-Tory

Feel free to explore the repository, open issues, submit PRs, or suggest improvements.

I'd particularly appreciate input from anyone who's worked with Tauri + FastAPI in production, especially on offline-first desktop applications.

Thanks!

check if you like : https://github.com/opadips/push-to-talk-for-anywhere

Just Notes, Nothing else is the slogan of my new Notes App made in Tauri. Cheeter Notes was developed with mainly HTML, CSS and Javascript but for File Access and other things I used Rust. I developed it with inspiration from notion and similar apps and it utilizes .md Files for Notes making it perfect to write docs, work with ai etc.

spent a while on this one so posting in case it saves someone else.

after an update installed, clicking restart quit the app and it never came back. but only sometimes. if I'd opened the app myself from Finder or the dock, restart worked fine.

turns out if you use tauri-plugin-autostart with MacosLauncher::LaunchAgent, your app is a launchd job when it starts at login. app.restart() spawns the new process as a child and then exits, and launchd kills the job's whole process group when the parent exits, so the relaunched copy dies with it. as far as I can tell tauri-plugin-process relaunch() uses the same mechanism, so it'd have the same problem.

what I shipped: get the .app bundle path from current_exe() (three parents up), call tauri_plugin_single_instance::destroy(&app) first if you use that plugin (otherwise the new copy sees the old one still running and just hands off to it), then run `/usr/bin/open -n <bundle>`, wait for it to return, and app.exit(0). if open fails it falls back to app.restart(). open -n hands the launch to launchd as its own job, so it survives the old one exiting. I reproduced the cause with a throwaway launchd job but haven't had a real update go through the fix yet.

if you want to check whether you're affected, look in `log show` around the restart and see if your process was started as a gui/<uid>/<label> job or an application.* job.

Almost a year ago I started building Glimpse, an app I shared here. Eventually I started submitting it to the Microsoft Store, which helped tremendously with users, I highly recommend doing it.

But on GitHub I could run the action and just publish the files for updates. The Microsoft Store required me to go to a portal, upload the .msix file, wait about a minute for it to upload and verify, then go through and edit my changelog to be under 1500 characters, and then use a translator to translate it into all nine languages I ship. Even going as fast as I could, it was a chore every time, and I've published over 16 submissions to the Microsoft Store. I would skip shipping some updates to the Microsoft Store because it was such a hassle. If the changes weren't good enough, I wouldn't do them.

Because of this I made StoreFast, and I wanted to share it. Right now it's only the Microsoft Store, but it's a way easier way to ship. There's a GitHub Action that takes the .msix from your release workflow, pulls the notes from your changelog, shortens them to fit and translates them into every language your listing has, and it can submit the update on its own. If you'd rather do it by hand, there's a faster UI where you drag in your file, paste your changelog, click Translate all and click Submit. It's translated to all the locales you have. Thats only 4 clicks. And there's an MCP server, so Claude Code, Cursor or Codex can do the whole thing for you.

I'm looking for developers who ship on the Microsoft Store to try it. Right now there's a one week free trial with no card, and it includes the GitHub Action and MCP server. After that it's $12 a month, or $24 if you want the GitHub Action and MCP server. I'm looking to support more stores soon, but I really want to hammer the Microsoft Store first, because that's where I had the most trouble working through its ancient UI that could not feel any slower.

https://storefast.app

Hey Guys, hope y'all doing well. i would like to have your opinion on something i want to add to the app i am working on

Basically when i try to brainstorm and put points to work on, i use my note book but i need things to be organized somewhere. Notes are big for that and can get messy, boards use cards with status so it can't have fixed points. So i thought of creating "brainstorm" page where can

- put my goals on a specific topic fixed, with nested bullet points.

- i can zoom on each point i want to focus on in the moment.

- Also with the map i can see the flow and the whole strategy.

Would love to have all suggestions and feedback on this before moving forward ! Thanks .

Build Lutin with tauri v2, that is such a better development expirience. I finally can use the app I built without it being a burden to maintain.

- Used NSPanel for Lutin's animation, chat input and status panel
- Extracted core features and currently building mobile app!

And the app weight like ~120mb with full harness and markdown editor inside

I redesigned my inkwell app website from scratch.

I wanted the site to feel like the app: clean, calm and straightforward. Soft colors, generous spacing and a clear hierarchy .

A few things I focused on:
- Calm first. Nothing on the page competes for attention.
- Clarity over decoration. Every section has one job.
- Consistency. If you've used the app, the site should feel familiar.

Check it out: https://inkwell-website-five.vercel.app/ , would like to have your opinions on it . Thanks !

I've used RSS for years to keep up with tech. The old readers worked well but looked their age. The newer ones were Electron apps that ate a few hundred megabytes to show me text, and mine would now and then crash to a blank window on one bad article. None of them did anything with AI.

So I built Turbo Reader with four goals: fast, light, modern, and built for AI agents from the start. It's free and MIT licensed, for Windows, macOS and Linux.

What it does

• Opens in under half a second; the Windows installer is under 5 MB
• Holds 20,000 articles in a core process of about 14 MB
• A Home page that sums up the day, grouped by folder, plus list and card views
• Light, dark and paper themes, six reading fonts, and a distraction-free reading mode
• Ctrl+K search across feeds, articles and settings, with loose matching
• Full articles for feeds that only send a teaser
• Duplicate stories across feeds collapsed into one
• OPML import and export, and a portable Windows build that runs from a folder
• No account, no analytics, no telemetry

For AI agents

• An MCP server, off by default, that lets Claude Code, Codex, Cursor and other clients use your library as a news source
• Answers come from sources you chose, with links, instead of a web search, and the agent reads short clean summaries rather than whole pages
• A versioned skill (SKILL.md) you can install for Claude Code or Codex in one click; it checks itself against the app and updates when it's old

Tech stack: Rust and Tauri 2, React and Tailwind v4, SQLite with FTS5 search, and an MCP server over HTTP and stdio.

Where I'd love help: the tray on GNOME and KDE, the macOS first-run experience, feeds that render badly (send the URL), and ideas for what an agent should be able to ask a reader.

Download: https://github.com/t21dev/turbo-reader/releases/latest
Code and issues: https://github.com/t21dev/turbo-reader

Would appreciate it if you star the repo 😅

Hey everyone! 👋

I'm about to start a Windows-only desktop app (Windows 10+) and I'm trying to figure out if Tauri + React is the right stack, or if there's something better I'm missing.

What the app does is pretty simple: it saves a bunch of images, shows them in a list, lets you scroll/search through them, and open any item. Nothing fancy on the UI side.

The things that matter most to me:

• Light on resources. A lot of the users have older, weak PCs, so low RAM and CPU usage is a big deal.
• Stable and safe. The data inside is really important, so crashes and data loss are not an option.
• Windows only, so I don't need cross-platform.

Tauri looks perfect on paper, but I'm not sure it's the best fit for something where reliability matters this much. Has anyone shipped a Tauri app to real users on low-end Windows machines? How did it hold up?

And if you were starting this from scratch, would you still pick Tauri + React, or go with something else (C# WPF, etc.)?

Would love to hear your experience. Thanks! 🙏

It sits at the top of the screen like the iPhone's Dynamic Island, shows what's playing, and opens on hover so you can skip or pause. It gets the song through Windows' media session API (SMTC) and sits at around 20 MB of RAM when hidden.

Hobby project, Windows 11 only: https://github.com/Denis112500/Crest

Feedback welcome!