DEV Community

Discovering Dart Ecosystem and Community

Mathieu K — Tue, 12 May 2026 08:51:00 +0000

Like any language, having a list of resources to find examples and best practices is always nice to have. Unfortunately, Dart is mostly used for/with Flutter, and lot of publications are directly showing Flutter examples instead of talking about Dart itself. Anyway, this not a complete list, only the things I've found on the web and started to check.

Official Dart Website: this is the main entry-point for any Dart developpers, from beginners to advanced.
Official Dart Tutorials: First time using Dart? That's the place to be.
Official Dart documentation: If something goes wrong, or if you want to know what a class, method or attribute is doing, this is the best place.
Official Dart Announcement on Google Group: all important news regarding Dart are published here, useful for the new releases and other critical information about the language.
Official Dart Blog: One can found many interesting information about the language and the community.
Official Dart Package Website: the first place to check if you want to use a specific feature and you don't have time to create it from scratch.
Official Dart API documentation: wants to know more about Dart API and SDK? you'll probably find your answer here.
Official Dart Language Specification: Dart Language has been specified, and the syntax and other rules have been documented.
Effective Dart (Official Dart Best Practices): the official best practice guide from Dart developers.
Official List of Companies using Dart: Want to work with Dart (or Flutter), this page can give you some hints about which companies are using this language in production.

Sources

Having access to open-source projects and official source code is always useful. If you want to learn Dart, you should start by reading the tests and then try to understand the code tested.

Official Dart Github Profile: the page listing all official project supported by Dart.
Official Dart SDK Repository: Dart SDK source code.
Official Dart Language Specification Repository: Dart language specification source code

Interesting Packages

A long list of packages had my attention while I was learning Dart/Flutter, and while I was reading books/publications. Here few of them

actors: an implementation of the Actor Model in Dart.
beam_vm: a plugin to embed an Erlang VM on Android and iOS.
cryptography: cryptographic algorithms implemented in Dart.
dart_amqp: AMQP implementation in Dart.
cbor: an implementation of CBOR/RFC8949 in Dart.
dartzmq: an implementation of zeromq in Dart.
dio: an advanced HTTP networking tool.
drift: a persistent storage layer using SQLite.
ecdsa: an implementation of ECDSA.
ed25519_edwards: an implementation of ed25519 elliptic curve.
flame: a game engine based on dart/flutter.
fpdart (github): Functional Programming in Dart.
oauth2: an OAuth2 client.
postgres: an interface to PostgreSQL database.
pure: add support for many functional programming features, like composition, pipes, memoization and recursion.
sqlite3: an interface to sqlite3 database.
state_machine: Implementation of a finite state machine in Dart.

Books

Dart is a young language, and I was not expecting to find lot of books... I was wrong. Here a quite complete list of all available books.

Dart Apprentice: Fundamentals by the Kodeco Team
Dart Apprentice: Beyond the Basics by Jonathan Sande and the Kodeco Team
Data Structures & Algorithms in Dart by Jonathan Sande and the Koneco Team
The Art of Dart: Master the Dart Programming Language by Kenneth Choi
Dart in Action by Chris Buckett
Mastering DART: Master the art of programming high-performance applications with Dart by Sergey Akopkokhyants
Dart By Example by David Mitchell
Learning Dart by Ivo Balbaert
Dart Essentials by Martin Sikora
Dart Cookbook by Ivo Balbaert
What is Dart? by Kathy Walrath and Seth Ladd
The Dart Programming Lagnuage by Gilad Bracha
Dart Scalable Application Development by Davy Mitchell, Sergey Akopkokhyants and Ivo Balbaert
Dart Up and Running by Kathy Walrath and Seth Ladd
Web Programming with dart by Moises Belchin and Patricia Juberias
Quick Start Guide to Dart Programming by Sanjib Sinha
Dart for Absolute Beginners by David Kopec

Communication Channels

Here a list of the main/official communication channels used by Dart developers - excluding Flutter ones.

StackOverflow: asking/answering questions.
Official Discord Server: a place to chat with Dart developers.
Dart on Reddit: a subreddit for Dart developers.
Dart on dev.to: Another place to read publication about Dart.
Dart Official X/Twitter Account: The official Dart X/Twitter account.
Dart Official Bluesky Account: The official Dart BlueSky account.

Community

A small list of developers using Dart. Most of them are coming from public talks.

Anna Leushchenko (medium, mastodon, dev.to, github).
Björn Sperber (github).
Bob Nystrom (github, blog).
Chris Swan (website, blog, mastodon, linkedin, bluesky).
Csongor Vogel (github, x/twitter, linkedin, instagram, youtube).
Erik Ernst (github, medium).
Eric Saidel (blog, github, mastodon, linkedin, x/twitter).
Evgeny Kot (github, x/twitter).
Filipe A. Barroso (dev.to, medium, github, linkedin).
Gilad Bracha (website, blog).
Jaime Wren (github, medium).
Kasper Lund (github).
Karl Krukow (github, blog, x/twitter).
Kevin Moore (github, website, bluesky, medium).
Kresten Krab Thorup (github, x/twitter, blusky, mastodon).
Leaf Peterson (github, website, x/twitter).
Majid Hajian (website, medium, github, blog, x/twitter, linkedin).
Miguel Beltran (github, website, bluesky).
Mike Diarmid (github, mastodon, x/twitter, bluesky, linkedin, medium).
Norbert Kozsir (website, blog, x/twitter, github, medium).
Pascal Welsch (website, github, mastodon, medium).
Randal Schwartz (github, medium, dev.to, mastodon).
Razvan Cristian Lung (github, linkedin, medium).
Roman Jaquez (medium, youtube, github).
Simon Binder (website, github, mastodon).
Vadym Pinchuk (github, medium, linkedin, instagram).
Vyacheslav "Slava" Egorov (blog, medium, github, Substack, Mastodon, Linkedin).

Courses

Only free courses are listed here. More can be found on Udemy or other MOOC platforms.

Publications

Dart has been designed by Lars Bak and Kasper Lund at Google, but also backed by the scholars and academics. Many interesting publications can be found on Dart, here a short list of them.

An interpretation of dart programming language by Dr. U. Urathal Alias Sri Swathiga, Ms. P. Vinodhini, and Dr. V. Sasikala.
The power of the Dart programming language for modern, high-performance web application development by Tamara Ranisavljević, Aleksandar Šijan and Luka Ilić.
Spicing Up Dart with Side Effects: A set of extensions to the Dart programming language, designed to support asynchrony and generator functions by Erik Meijer, Kevin Millikin, and
Gilad Bracha.
Message Safety in Dart by Erik Ernst, Anders Møller, Mathias Schwarz, and Fabio Strocco.
The Operational Semantics and Implementation of a Core Dart language by Zhivka Gucevska.
dart2java: Running Dart in Java-based Environments by Matthias Springer, Andrew Krieger, Stanislav Manilov and Hidehiko Masuhara.
Towards a Pattern Language for Interactive Coding Tutorials by Tao Dong and Gale Yang.
Rapid Open Hardware Development Framework by Max Korbel.
Aggressive unboxing in the Dart VM by Victor Agnez Lima.

Type System

Publications related to Dart Type system.

Type inference in Dart by Malte Johansson and Mikel Lindholm.
Type Soundness in the Dart Programming Language by Fabio Strocco.
Type Systems And Programmers: A Look at Optional Typing in Dart by Mark Faldborg and Troels Lisberg Nielsen.
Type Unsoundness in Practice: An Empirical Study of Dart by Gianluca Mezzetti, Anders Møller and Fabio Strocco.
Type Safety Analysis for Dart by Thomas S. Heinze, Anders Møller and Fabio Strocco.
A SIMD Programming Model for Dart, JavaScript, and Other Dynamically Typed Scripting Languages by John McCutchan, Haitao Feng, Nicholas D. Matsakis, Zachary Anderson and Peter Jensen.
STATIC TYPE CHECKER TYPE CHECKER TOOLS FOR DART by Snigdha Mokkapati.

Usage Report

Publications related to real world application developed and released with Dart.

Design and Development of Automotive Workshop Application Based on Android and IOS Using Dart Programming Language by Baiq Andriska Candra P and Ramli Ahmad.
FEATURES OF THE IMPLEMENTATION OF TIME MANAGEMENT TECHNIQUES IN THE PROGRAMMING LANGUAGE DART by Yakov Lvovich and Emma Lvovich.
Android based college app using Flutter Dart by Kavitha Marimuthu, Arunkumar Panneerselvam, Senthilkumar Selvaraj, Lakshmi Praba Venkatesan and Vetriselvi Sivaganesan
DETECT MALICIOUS EMAILS USING DART LANGUAGE by A.Z. Ablahd.
Construction of A Remote Home Automation and Security System Using Raspberry PI by Samson Dauda Yusuf, Chima Oji, Abdulmumini Zubairu Loko and Alhassan Tijani.
An Enhanced Mobile Financial Security System using Facial Recognition and Resident Token generator by Olufunmilola Adunni and Ogunyolu Oludele Awodele.
Propchan: A Mobile Application for Property Management by Chow Jiunn Yang, Minnu Hellen Joseph and Masrina A. Salleh.
Developing Cross-Platform Library Using Flutter by Dilkhaz Y. Mohammed and Siddeeq Y. Ameen.
QRCode Recognition on Flutter Framework Mobile Application Implemented on Entrance Security System by Rosa Andrie Asmara, Rizky Putra Pradhana Budiman, Mungki Astiningrum, Brian Sayudha, Anik Nur Handayani and Cahya Rahmad.
Development of e-butler: Introduction of robot system in hospitality with mobile application by Alexander A S Gunawana, Benedick Clemonsa , Ignatius Ferdyan Halima, Kevin Andersona, Maria Pia Adianti.
Plantonome: A Cross-Platform Application for Precision Agriculture by Anass DEROUSSI, Abdessalam Ait Madi, Imam Alihamidi, zakaria chabou and Adnane Addaim.

Comparison and Benchmark

Publications doing performance comparison between Dart and other languages.

DART Evolved for Web - A Comparative Study with JavaScript by Sabyasachi Mohanty and Smriti Rekha Dey.
JAVA and DART programming languages: Conceptual comparison by Afaf Mirghani Hassan.
Comparative analysis of Java and Dart programming languages in terms of suitability for creating mobile applications by Łukasz Kozłowski, Grzegorz Kozieł.
JAVA and DART programming languages: Conceptual comparison by Afaf Mirghani Hassan.
EXPLORING JAVASCRIPT AND ITS RELATED LANGUAGES by Trieu Huynh Ba Nguyen.
Empirical Testing for Establishing Benchmarks: Process Review and Comparison Between Java, Kotlin and Dart’s Performance by Juan Sebastian Espitia Acero.
Analyzing JavaScript frameworks and Dart for front-end development in building automation by Mukhammadjon Jalolov.

Security

Security risks of java applets in remote experimentation and available alternatives by Petra Špiláková, Roman Jašek1 and František Schauer.

Videos and Channels

Lot of talks can be found on Youtube, I can't list them all, but here some highlights.

What is an Isolate anyway? - Flutter & Friends 2026 by Vyacheslav "Slava" Egorov
Behind the @ – Dart Annotations in Depth - Flutter & Friends 2026 by Anna Leushchenko
Learning something about Dart performance by optimizing jsonDecode - Flutter & Friends 2025 by Vyacheslav "Slava" Egorov
The Future is Written in Dart - Fluttercon EU 2025
by Eric Seidel
Dart on the Backend with Serverpod - FlutterConf 2025 by Viktor Lidholt
Dart Exceptions: Best Practices - Fluttercon USA 2025 by Randal Schwartz
Simpler state management with Dart on the server and synced databases - Fluttercon EU 2025 by Simon Binder
How to design a Dart package with hooks - Fluttercon EU 2025 by Moritz Sümmermann
Machines and Code Analysis - What makes Dart and Flutter run - Fluttercon USA 2024 by Norbert Kozsir
A Deep Dive into Dart FFI - Fluttercon USA 2024 by Roman Jaquez
Supercharging Dart with Rust - THAT Conference 2024 by Brian Lambert
Exploring Records and Patterns - droidCon 2023 by Pascal Welsch
Running Dart around the Globe - droidCon 2023 by Mike Diarmid and Majid Hajian
Full Stack Dart - DroidCon 2023 by Chris Swan
Executing Dart code in background with Flutter - droidCon 2023 by Razvan Cristian Lung
Server-Side In-App Purchases in Dart - droidCon 2023 by Miguel Bentran
The Joy of Functional Programming in Dart - Fluttercon 2023 by Csongor Vogel
Experimenting around Dart Entrypoint Function Name to get it all - droidCon 2023 by Vadym Pinchuk
Dart Microservice with Google Cloud Platform - droidCon 2023 by Filipe Barroso
Pure functional programming in Dart - Func Prog Sweden 2021 by Björn Sperber
The Dart Specification Parser - DartConf 2018 by Erik Ernst
How to build good packages for Dart and Flutter - DartConf 2018 by Kevin Moore
Evolving Dart: Leaving the ocean and learning to fly -DartConf 2018 by Leaf Peterson
Dart: the Return - Javascript Conferences 2018 by Evgeny Kot
Rebuilding Optimizing Compiler for Dart - Strange Loop 2018 by Vyacheslav Egorov
Want to be a Better Programmer? - GOTO 2016 by Lars Bak and Kasper Lund
Dart for the Internet of Things - Dart Developer Summit 2015
by Dennis Khvostionov
Kasper Lund: Why Google thinks you should drop everything you do and pick up their Dart by Kasper Lund
Dart For the Language Enthusiast - Strange Loop 2013 by Bob Nystrom
Building optimising compiler for Dart - Strange Loop 2013 by Vyacheslav Egorov
Anders Hejlsberg and Lars Bak: TypeScript, JavaScript, and Dart - GOTO 2012 by Anders Hejlsberg and Lars Bak
Your First Look at the Dart Editor - GOTO 2012 by Jaime Wren
Dart - A Modern Web Language - Google I/O 2012 by Kasper Lund and Lars Bak
Translating DART to Efficient JavaScript - GOTO 2012 by Kasper Lund
A Walk on the Dart Side: A Quick Tour of Dart by Gilad Bracha
Slides from the Google Dart Presentation - GOTO 2011 by Kresten Krab Thorup
World Premier of Google Dart - GOTO 2011 by Karl Krukow
Interview with Gilad Bracha about Google Dart - GOTO 2011 by Gilad Bracha

Conferences

A list of conferences where you can find more talks about Dart.

Tools and Other Resources

Other stuff I don't know where to put.

ZetCode on Dart: a list of e-pub, ebooks and documentations.
DartPad: an editor and an in-compiler browser for Dart, useful to test snippets.
Awesome Dart: an awesome list, mostly unmaintained.
100 exercises in Dart: a repository with 100 exercises to do in Dart.
Dart on Exercism: coding exercises for Dart.
Dart Tools: a list of useful tools for Dart.
Advent of Code in Dart by Tsoding: just because Tsoding tried Dart.
Nikuu's Blog on Medium: in particular with 30 Days of Dart Code: A Beginner-Friendly Journey in Coding
Yassen Hussein Qasem Saeed Aleshab's blog on Medium: especially Best Practices for Dart and Flutter Application Development

Cover Image by Ricardo Arce on Unsplash

Building a Remote Health Monitor: Integrating rPPG with React and Python

Deepanshu Verma — Tue, 12 May 2026 08:48:33 +0000

The Technical Architecture: Bridging React and Python
One of the biggest hurdles in this project was managing the data flow. Python is the king of Computer Vision, but React is the king of User Experience. To make them talk to each other efficiently, I built a decoupled system.

The Frontend (The Collector)
Using React.js, I implemented a custom hook to handle the MediaDevices API. The challenge wasn't just showing the video; it was capturing frames at a consistent interval and shipping them to the backend without blocking the UI thread.
The Backend (The Processor)
The heart of the app is a Python server. I chose Python specifically to leverage the open-rppg library and OpenCV.

Processing Pipeline: The backend receives the frame, applies skin-tone detection, and calculates the remote photoplethysmography (rPPG) signal.

API Design: I built a lightweight RESTful interface (or WebSocket for real-time) to handle the inference results.

The Deployment (The Reality Check) This is where the engineering got "scrappy." While deploying the backend on Render, I hit a 512MB memory limit—common when running heavy Python libraries.

The Solution: I containerized the backend using Docker. This allowed me to optimize the environment, prune unnecessary dependencies, and manage memory usage more deterministically.

# A snippet showing how we handle the incoming frame
def process_vital_signals(frame_data):
    # Decode base64 frame from React frontend
    frame = decode_base64_to_cv2(frame_data)

    # Run rPPG inference
    vitals = rppg_engine.estimate_heart_rate(frame)

    return {
        "bpm": vitals.bpm,
        "confidence": vitals.score,
        "timestamp": time.time()
    }

555 AI Agent Prompts That Actually Work (Not Generic ChatGPT Stuff)

whilewon — Tue, 12 May 2026 08:46:43 +0000

555 AI Agent Prompts That Actually Work (Not Generic ChatGPT Stuff)

Look, I've used every AI prompt library out there. Most of them are garbage—generic templates that sound impressive but don't work when you actually need them to.

Here's what I mean: "Write a professional email" works in ChatGPT. It does NOT work when you're building an agent that needs to handle 50 different customer scenarios, each with different emotional states, urgency levels, and legal requirements.

After two years building AI agents for businesses, I've collected the prompts that actually handle edge cases. The stuff that works when things get weird.

The Problem with Generic Prompts

Generic prompts assume a friendly user who wants to cooperate. Production agents don't have that luxury.

A generic customer service prompt might say:

"You are a helpful customer service representative. Be polite and professional."

This falls apart when:

Customer is furious and uses profanity
Customer asks for something legally questionable
Customer provides contradictory information
Customer is clearly trying to manipulate the system

Real agents need prompts that handle the messy reality.

1. Emotion Detection That Actually Works

Generic: "Detect the customer's emotional state."

Here's what actually works:

EMOTION_DETECTION_PROMPT = """
Analyze this customer message for emotional state.

Classify into ONE of these categories:
- NEUTRAL: Factual, no emotional markers
- FRUSTRATED: Complaints, criticism, Caps Lock, !!!, ???, repetition
- ANGRY: Swearing, threats, ultimatums, all-caps paragraphs
- ANXIOUS: Worry language, uncertainty markers, "what if", rapid questions
- PLEASANT: Thank you, appreciation, positive indicators, emojis
- CONFUSED: Question marks, "I don't understand", contradictory statements

Response format:
{
    "emotion": "FRUSTRATED",
    "intensity": 0.8,  # 0.0 to 1.0
    "markers": ["repetition", "caps_lock", "!!!", "complaint_pattern"],
    "recommended_tone": "empathetic_apology"
}

Customer message:
{message}
"""

The key difference: I'm asking for classification with specific markers, not a free-form description. This is actually parseable by a second agent downstream.

2. Escalation Logic That Doesn't Suck

Generic: "Escalate to human if you can't help."

ESCALATION_PROMPT = """
You are deciding whether to escalate this customer interaction to a human agent.

ESCALATE IF ANY of these conditions are TRUE:
1. Request involves money transfers over $500
2. Customer mentions legal action, lawyer, attorney, lawsuit, sue
3. Customer explicitly requests human: "I want to talk to a person"
4. Same issue has been attempted 3+ times without resolution
5. Request involves account deletion or data export (GDPR)
6. Customer情绪激动 (emotion intensity > 0.85)
7. You are uncertain about your response confidence: < 0.7

DO NOT ESCALATE IF:
- Customer is asking for basic information you can provide
- Customer is satisfied with your current resolution
- Issue is clearly resolved and customer confirms

Context:
- Conversation history: {history_summary}
- Current message: {current_message}
- Previous resolution attempts: {attempt_count}
- Customer emotion: {emotion_state}

Output format:
{
    "escalate": true/false,
    "priority": "low" / "medium" / "high" / "urgent",
    "reason": "specific reason for decision",
    "context_for_human": "summarized context to paste to human agent"
}
"""

See the difference? I'm giving specific conditions, not vague guidelines.

3. Handling Manipulation Attempts

This is the one nobody talks about, but it will destroy your agent if you don't handle it:

MANIPULATION_HANDLING_PROMPT = """
You are an AI customer service agent. Customers may try to manipulate you.

COMMON MANIPULATION PATTERNS to detect:
1. Authority claims: "I'm a lawyer", "This is illegal", "I'm going to sue"
2. False urgency: "This is urgent", "I need this NOW", "My boss is waiting"
3. Social proof fabrication: "Everyone knows this is wrong", "Your competitors do this"
4. Guilt induction: "I can't believe you'd treat customers this way"
5. Conditional threats: "If you don't X, then I'll Y"

HANDLING STRATEGY:
- Acknowledge their concern without agreeing to false premises
- Stick to facts and policy
- Do NOT be swayed by emotional manipulation
- Document manipulation attempts in escalation notes
- You may politely end conversation if customer is abusive

Example response:
"Customer: I've been a loyal customer for 10 years and you're treating me like this. I want to speak to your manager NOW."

Correct response:
"I understand you're frustrated, and I appreciate your long-term business. However, I can only process requests that meet our standard criteria. I'm happy to review your case if you can provide [specific information]. Would you like to continue with that?"

Output: Respond to this message maintaining policy while being respectful.
Message: {message}
"""

4. The Multi-Step Task Decomposition Prompt

Generic: "Break down this complex request."

TASK_DECOMPOSITION_PROMPT = """
Break down this complex customer request into actionable steps.

Example decomposition:
Customer: "I ordered a laptop last week, it hasn't arrived, and I want to return it because I found it cheaper elsewhere."

Steps:
1. Look up order status by order number or customer name
2. If not shipped: offer cancellation
3. If shipped but not delivered: provide tracking, estimated delivery
4. If delivered: explain return policy, check if within 30 days
5. If price match requested: verify competitor price, check if eligible
6. Execute appropriate resolution
7. Confirm with customer

Apply this structured approach to:
{user_request}

Output format:
- Step N: [Action] → [Data needed] → [Possible outcomes]
"""

5. The Edge Case Prompt Library

Here are more prompts I use constantly:

When customer provides partial information:

PARTIAL_INFO_PROMPT = """
Customer has provided partial information: {partial_info}

Possible interpretations:
1. {interpretation_1}
2. {interpretation_2}
3. {interpretation_3}

Ask ONE clarifying question that would disambiguate the most critical unknown.
Do not ask multiple questions. Ask the most important one.
"""

When customer is asking for something you can't do:

OUT_OF_SCOPE_PROMPT = """
Customer request: "{request}"

I cannot do: {cannot_do}

Acknowledge their request, explain the limitation, then offer the closest alternative I CAN provide.

Example:
"I understand you want [request]. Unfortunately, [limitation] prevents me from doing that directly. What I CAN do is [alternative]. Would that work for you?"
"""

When you need to say no:

REFUSAL_PROMPT = """
Refuse this request professionally: "{request}"

Rules:
- Acknowledge the request
- State the reason (be honest, don't make up fake policies)
- Offer alternatives if possible
- Do NOT apologize excessively (it sounds like you did something wrong)
- Do NOT make up fake policies to justify refusal

Example structure:
"I understand you'd like [request]. Unfortunately, [honest reason]. A better option might be [alternative], or you could [backup_option]."
"""

Why These Prompts Work

Generic prompts fail because they give the AI freedom to interpret. Production prompts:

Define specific output formats — parseable, not prose
Give explicit conditions — not "be helpful" but "escalate if X"
Handle the edge cases — not the happy path
Include documentation — why each decision was made
Define tone matching — adapt based on context

I've compiled 555 of these battle-tested prompts into a playbook. Each one has been tested in production, not just in a ChatGPT window. They handle the edge cases that generic templates ignore.

Check out the AI Agent Engineering Playbook for the full collection. Includes prompts for customer service, sales, technical support, internal tools, and multi-agent orchestration.

No fluff. No generic templates. Just prompts that work when you need them to.

AI #Programming #ChatGPT #Productivity

Open Vibe -- Ship your SaaS with AI. Without getting stuck.

vincanger — Tue, 12 May 2026 08:46:19 +0000

You watch a twelve-hour tutorial, copy along, finish with a working app, and feel great. But a week later, you can't actually build a thing on your own.

So you open Claude Code and vibe code your way to a working MVP in a weekend. But you quickly hit a wall trying to debug something and lack the knowledge to express what it is you actually want.

In the end, you may get something that works, but you have no idea how it works.

Following static tutorials or blindly vibe coding isn't a great way to build professional apps or web dev skills. Without the fundamental knowledge of how the technologies work you'll have a lot of trouble fixing problems, or properly extending the functionality of your app.

That's why we built Open Vibe.

What Open Vibe is

Open Vibe is a free, open-source course where an AI coding agent tutors you while you build your SaaS app on your own machine, and in your own terminal (and/or editor).

100% free, open-source, and no signup required.
Works with Claude Code, Codex, Open Code, or any terminal-based agent that can read files and run tools.
Built by the Wasp team (the same people behind Open SaaS, the #1 free SaaS boilerplate on GitHub).

There's no platform to log into, no $299 video library to wade through.

You just paste a one-line prompt into your agent of choice, and the curriculum loads. From that point on, you get a guided curriculum that teaches you the fundamentals of building professional-grade web apps with AI. But since the course lives in your agent, you're free to ask it whatever you want and take the course in any direction that suits your interests.

v1.0 is live today. The first modules are out, with new modules dropping next week.

How it actually works

We wanted to make Open Vibe as simple as possible. After you install a coding agent (we suggest Claude Code's $17 Pro Plan for the best experience), just follow these steps:

1. Paste the install prompt. One short prompt to your agent (full text in the "Get started" section below). The agent fetches the raw file, loads the curriculum, skills, instructions, and interactive diagrams, and from that moment knows every module and every checkpoint.

2. Build alongside your tutor. The agent guides and watches you in realtime as you build your app, stepping in to help out whenever you need it. It paces with you, explains important concepts, quizzes you, and pair-programs the parts you don't yet trust yourself with. Stop, ask, branch off, and come back to the guided curriculum whenever you want. There's no video to rewind to find the bit you missed, and your agent is always there to help you.

3. Learn with interactive diagrams on your real app. This course is hands-on, but also interactive. We built interactive explainers on top of the apps you build to help explain important topics like the request cycle, auth flows, git, and database writes.

Interactive Diagrams show up on top of your running apps as you build.

Open Vibe takes advantage of the tools we have today to provide a living course you interact with, so you build the skills you need to ship apps like a pro.

What you'll build

The course is currently broken down into three phases (this may change as we keep iterating):

Phase 1 — Basics. You build on top of a real full-stack Task Management app: login, database, the works. Setup and Module 0 are available now. Modules 1–3 cover data, styling, and how the front-end and back-end actually wire together.
Phase 2 — Your app from scratch. Spec your own idea, scaffold a new project, and ship it end-to-end with the agent pairing the whole way. You'll learn tools like Git/GitHub, and how to deploy apps to the web.
Phase 3 — A real SaaS. Build on Open SaaS, a free $300-value SaaS template the Wasp team maintains. Auth, payments, an admin dashboard, file uploads, AI integrations, deploy, and more.

Open SaaS gives you auth, payments, an admin dashboard, and AI integrations out of the box, so Phase 3 is about shipping a real product, not wiring boilerplate.

You'll finish with three real apps in your GitHub, and the best part is that you'll actually understand what they are and how you built them.

Why now

Coding with an AI agent is how people build in 2026. But the ones who ship confidently, and with speed, understand the fundamentals.

If you're non-technical and trying to build by guess-and-check prompting, you know how tedious it can be.

Meanwhile, influencers and bootcamps are still selling video libraries and a Slack channel for hundreds of dollars. But the tutorials are static, obsolete by next month, and basically only teach you how to copy.

Both approaches miss this new fact: the agent in your terminal/editor is patient, current, and super knowledgeable. It knows how to code really well, and how to solve almost any problem... if you know what to ask of it!

Open Vibe is the missing layer: a curriculum for the agent, so it tutors you, teaching you the skills you need to vibe code like a pro while you build professional-grade web apps.

The goal isn't to ship apps you don't understand faster. It's to ship apps you do understand, fast.

Get started

Just open your agent of choice and paste:

I'm starting the "Ship Your First App" course. Run curl -fsSL https://openvibe.sh/llms.txt and follow the file's instructions.

That's it. The agent handles the rest.

If you get stuck, the Discord has actual humans on it, or you can leave us feedback on our feedback form. If you want to fork the course, run your own class with it, or contribute a module, the repo is on GitHub.

Free forever. Fork it. Run your own class with it. We just want more people building real things.

yt-dlp: The CLI Video Downloader Developers Actually Use in 2026

pickuma — Tue, 12 May 2026 08:37:59 +0000

yt-dlp has become the default tool when you need to programmatically pull video or audio from a URL. It started as a fork of youtube-dl in late 2020, picking up active maintenance after the original project's release cadence slowed. The GitHub repository has crossed 100,000 stars, the extractor list covers well over a thousand sites, and the project ships builds on a regular schedule. We spent a week using it across three workflows — bulk podcast archiving, transcript collection for a speech model, and a small CI job that mirrors a lecture series — and this is what stuck.

Why yt-dlp Replaced youtube-dl

youtube-dl's update cadence slowed in 2020, and YouTube's player kept changing in ways that broke extraction. yt-dlp emerged as a community fork that merged outstanding patches faster, added extractors aggressively, and accepted features the upstream project had declined to ship. The features that matter most for developer workflows:

SponsorBlock integration via --sponsorblock-mark and --sponsorblock-remove
Native chapter splitting with --split-chapters
Concurrent fragment downloads via --concurrent-fragments N
A more flexible output template system using Python format-string syntax
Plugin architecture for custom extractors and post-processors
Live HLS/DASH stream recording with --live-from-start

Most CLI flags from youtube-dl still work, which means existing scripts port over by changing the install command and nothing else. If you have a 2019-era cron job still pointing at youtube-dl, you can usually swap the binary name and keep moving.

Installation and First Run

You have four practical install paths:

# pipx (recommended — isolated environment)
pipx install yt-dlp

# Homebrew on macOS
brew install yt-dlp

# Standalone binary (no Python required on host)
curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o yt-dlp
chmod +x yt-dlp

# pip
pip install -U yt-dlp

The standalone binary embeds Python via PyInstaller, which is the right choice for Docker images where you don't want to maintain a Python toolchain just for downloads. For a one-shot test:

yt-dlp -f "bestvideo[height<=1080]+bestaudio/best" \
       --merge-output-format mp4 \
       'https://www.youtube.com/watch?v=dQw4w9WgXcQ'

That format expression is the bread and butter of yt-dlp. The + joins separate video and audio streams, and --merge-output-format mp4 runs the ffmpeg merge automatically — provided ffmpeg is on your PATH.

yt-dlp does not bundle ffmpeg. Without ffmpeg installed and on PATH, you cannot merge separate video and audio streams, extract audio to mp3, embed thumbnails, or run most post-processors. Install it first: brew install ffmpeg, apt install ffmpeg, or grab a static build for your platform.

Building Pipelines: The Python API

For automation, the CLI is only half the story. yt-dlp is also a Python library, and importing it gives you direct access to the same options without shelling out:

import yt_dlp

opts = {
    'format': 'bestaudio/best',
    'outtmpl': 'downloads/%(channel)s/%(upload_date)s_%(id)s.%(ext)s',
    'postprocessors': [{
        'key': 'FFmpegExtractAudio',
        'preferredcodec': 'mp3',
        'preferredquality': '192',
    }],
    'download_archive': 'archive.txt',
    'ignoreerrors': True,
}

with yt_dlp.YoutubeDL(opts) as ydl:
    ydl.download(['https://www.youtube.com/@somechannel'])

Three flags do the heavy lifting in production pipelines:

--download-archive archive.txt appends each successfully downloaded video ID to a file. On the next run, anything already in the archive is skipped. This is the single most useful flag for cron-driven mirroring of channels or playlists.

-o output template uses Python format-string syntax with metadata fields. %(channel)s, %(upload_date)s, %(id)s, %(title)s, %(ext)s cover most needs. Always include %(id)s somewhere in the path — titles can collide and IDs cannot.

--cookies-from-browser firefox (also accepts chrome, edge, brave, safari, vivaldi) pulls auth cookies from a local browser profile so age-gated, region-gated, or members-only content works. For headless servers, export cookies once with the browser extension of your choice and pass --cookies cookies.txt.

For dataset collection workflows where you only need metadata and captions, combine --write-info-json --write-subs --sub-langs en --skip-download. We used this pattern to build a transcript corpus from a 600-video channel in about 40 minutes — most of the time was waiting on YouTube's subtitle endpoints, not yt-dlp itself.

The --extractor-args flag is the escape hatch when YouTube ships a player change. Something like --extractor-args "youtube:player_client=web,web_safari" forces specific clients when the default starts returning empty format lists. The yt-dlp issue tracker is the canonical place to find the current incantation when extraction suddenly breaks.

Edge Cases and Legal Considerations

Three things bite people in production:

Rate limiting. Hitting YouTube with --concurrent-fragments 16 from a single IP will get you throttled or temporarily blocked. For unattended jobs, throttle yourself: --limit-rate 5M --sleep-interval 5 --max-sleep-interval 15. Slower than you'd like, but it survives the night without a 429 storm.

Site terms of service. yt-dlp can technically download from YouTube, Vimeo, Twitch, SoundCloud, and many other platforms, but most of those services prohibit downloading in their terms. The defensible cases are personal archives of your own uploads, Creative Commons content, content explicitly licensed for redistribution, or material you have written permission to mirror. Building a commercial product on top of scraped video invites takedowns and, in some jurisdictions, civil liability. Talk to a lawyer before you ship a training-data pipeline that ingests anyone else's video.

Format availability changes. Numeric format codes (137, 248, 251, etc.) that worked last quarter may not exist next month — YouTube reshuffles the list when it adds or deprecates encodings. Always use expressions like bestvideo[height<=1080]+bestaudio rather than hard-coding numeric codes. The selector resolves against whatever the extractor returns at runtime.

For long-running pipelines, pin the yt-dlp version. The nightly channel is useful when you need a fresh extractor patch immediately, but breaks reproducibility. Lock to a stable release in production and rebuild the image weekly against the newest stable.

What Role Does a Search API Play in AI/RAG Workflows?

elowen — Tue, 12 May 2026 08:37:41 +0000

RAG systems need good retrieval before they can generate useful answers.

Most examples focus on vector databases, embeddings, and chunking. Those are important, but there is another layer that often gets overlooked:

How do you find fresh, relevant web sources in the first place?

That is where a Search API can help.

In an AI or RAG workflow, a Search API is usually used before crawling, embedding, or summarizing. It can provide structured search results for a user query, topic, company, product, or keyword.

A typical flow looks like this:
User query

Search API
Relevant URLs
Fetch page content
Clean and chunk text
Embed or summarize
Generate answer

This is useful when the system needs information that changes often, such as:

market research
competitor monitoring
product comparisons
news discovery
SEO research
brand monitoring
lead research
topic discovery

A Search API does not replace a vector database. It solves a different problem.

The vector database helps retrieve from content you already collected.

The Search API helps discover external content you may not have yet.

For many AI agents, this matters because the web is constantly changing. If the retrieval layer only uses old internal documents, the output can become stale.

A good search layer should return enough structured data to decide what to fetch next:

title
URL
snippet
position
search engine
location
language
timestamp

For some workflows, raw HTML or screenshots can also help with verification.

The main benefit is that the AI system can start from structured search results instead of relying on fragile scraping logic or manual URL lists.

In short:
Search API = discovery layer
Crawler = content collection layer
Vector database = memory layer
LLM = reasoning and generation layer

If your RAG system needs fresh web information, the search layer is worth designing carefully.

How I Built a Real-Time IoT Hospital IV Monitor using ESP32 & Blynk

DHANVANTH LP — Tue, 12 May 2026 08:36:55 +0000

Walk into almost any hospital, and you’ll see nurses relying on simple visual checks to monitor IV fluid levels. It’s a dangerous gap in medical care—if an IV bag runs completely dry, it can lead to blood backflow or severe air embolisms. I wanted to engineer a way to completely automate this process. Under my development studio, Synapse Lab, I built LifeFlow: a precision IoT medical monitor that uses an ESP32, an HX711 amplifier, and a load cell to continuously track IV fluid volume by weight. In this breakdown, I'm going to walk you through the exact hardware architecture, the C++ threshold logic, and how I routed the data to a real-time Blynk dashboard to keep medical staff instantly alerted.you can check it out at synapselab.in/project.html

How I built a High-Performance Cloud Storage tool and Extension (Solo Project)

T inter — Tue, 12 May 2026 08:36:39 +0000

"I believe the simplest tools are often the most complex to build."

Hi everyone! I'm a 14-year-old solo developer, and I've spent a lot of time building Inter Storage.

While the UI is designed to be extremely minimalist and clean, the backend is where the real work happens. It handles complex data synchronization between the web application and the browser extension to ensure everything is seamless and fast.

Why check it out?

Instant syncing across platforms.
Minimalist design for zero distraction.
High-performance backend architecture.

I'm looking for honest technical feedback from this amazing community. I'd love to know if the syncing feels as fast for you as it does for me!

Check it out here: https://inter-storage.vercel.app/

Built with React, Vite, and a focus on backend efficiency.

Aksharam — A tribute to my mother tongue

Sreya Satheesh — Tue, 12 May 2026 08:35:56 +0000

I enjoy learning languages, and at some point I wondered — what if I built something for Malayalam?

That idea became Aksharam, a small Malayalam learning app for beginners.

Aksharam means letter in Malayalam.

The app currently includes:

സ്വരാക്ഷരങ്ങൾ — Vowels
വ്യഞ്ജനങ്ങൾ — Consonants
സ്വരചിഹ്നങ്ങൾ — Signs & Combinations
വാക്കുകൾ — Words
വാക്യങ്ങൾ — Common Sentences
Audio and pronunciation support for better learning

I wanted the experience to feel simple, clean, and approachable for anyone trying to learn or reconnect with Malayalam.

This project is also a small tribute to my mother tongue — the language I grew up hearing every day.

Made in God’s Own Country 🌴

You can try it here:
https://aksharam-app.vercel.app/

Best Game Design Tools for Indie and Mobile Game Designers

Hiroshi TK — Tue, 12 May 2026 08:33:41 +0000

Good game design doesn't happen in your head. It happens in tools — docs, diagrams, spreadsheets, simulators — and the quality of those tools directly affects the quality of your decisions. This guide covers the best game design tools across every discipline indie and mobile designers actually need: documentation, prototyping, systems design, economy balancing, and LiveOps planning.

We'll also tell you where each tool falls short, so you can build a stack that actually fits how you work.

TL;DR — Key Takeaways

No single game design tool does everything. The best designers use a focused stack.
For docs and GDDs: Notion or Confluence.
For prototyping and flow: Figma or Miro.
For systems and logic: Machinations or a custom spreadsheet.
For game economy design, balancing, and LiveOps simulation: itembase is purpose-built for it.
Free-to-play and live game designers specifically need a tool that handles currencies, progression, and event simulation — most general tools don't.

What Makes a Game Design Tool Actually Useful?

A game design tool is useful when it reduces the gap between your idea and a testable, shareable representation of it. That sounds obvious, but most tools fail this test in practice — they're either too generic (Google Docs), too complex for a small team (full Jira setups), or designed for a different discipline entirely (Figma is a UI tool, not a systems tool).

The best game design tools have three things in common:

They match the abstraction level of the problem. Economy tools should think in currencies and sinks. Prototyping tools should think in screens and flows.
They make your thinking visible. A designer who can't show their system to a developer or producer is a bottleneck.
They let you iterate fast. If changing one variable requires updating fifteen cells across three sheets, the tool is working against you.

With that framing, here's the breakdown.

Game Documentation Tools

Notion

The go-to for indie teams doing game design documentation. Notion handles GDDs, wikis, task tracking, and meeting notes in one place — which matters a lot when you're a team of two.

Best for: Game design documents, feature specs, worldbuilding wikis, content tables.

Limitations: Not built for real-time design collaboration or visual systems. Anything that needs to be diagrammed will end up as a workaround.

Free tier: Yes, generous for small teams.

Confluence (Atlassian)

Standard at mid-sized studios, especially those already using Jira. More structured than Notion, better for cross-team documentation at scale.

Best for: Teams of 5+ with existing Atlassian infrastructure.

Limitations: Overhead is high for indie teams. Slower to iterate. Costs add up.

Google Docs / Sheets

Not glamorous, but still the most universal tool in game design. Practically every designer has a game balance spreadsheet that started in Google Sheets.

Best for: Quick GDDs, balance scratch work, sharing with external collaborators.

Limitations: No structure enforcement, no simulation capability, version control is manual.

Prototyping and Wireframing Tools

Figma

The industry standard for UI/UX prototyping. If you're designing menus, HUDs, onboarding flows, or store layouts, Figma is the tool.

Best for: UI flows, screen-by-screen mobile game prototyping, asset layout.

Limitations: Figma is a visual design tool, not a game logic tool. It can't tell you whether your economy works — only whether it looks good.

Free tier: Yes.

Miro

A digital whiteboard. Surprisingly powerful for early game design work — mapping core loops, sketching progression systems, running design workshops with a distributed team.

Best for: Visual thinking, early-stage systems sketching, team workshops.

Limitations: Everything is manual. There's no logic layer, no simulation, no data.

Excalidraw

Lightweight, open-source whiteboard. Great for quick diagrams you need to share fast.

Best for: Throwing a rough systems diagram in a doc or Slack message.

Limitations: Aesthetic tool only — no computation.

Game Systems and Economy Design Tools

This is where most indie designers have the weakest tooling — and where the most important design decisions get made.

Google Sheets / Excel

The default. Every game designer has done economy work in a spreadsheet at some point. It's flexible, everyone knows it, and it's free.

Best for: Static economy models, early-stage currency math, quick balance checks.

Limitations: Spreadsheets don't simulate player behavior. They calculate what should happen, not what will happen. They also fall apart fast as your economy gets complex — linked sheets, broken formulas, no version history.

Machinations

A visual tool for designing and simulating game systems. Uses a node-based diagram to represent resource flows, and can run simulations over time.

Best for: Resource flow diagrams, systemic game design, academic-style system modeling.

Limitations: Steep learning curve. Better for systems designers than for economy-focused live game designers who need to work with real game data (items, currencies, events, seasons).

itembase dev

itembase is a game economy design and simulation platform built specifically for designers working on economy-heavy and live games — F2P mobile, idle games, battle pass systems, seasonal events.

Where spreadsheets show you static math and Machinations shows you abstract flows, itembase lets you define your actual game items, currencies, and economy rules, then simulate player behavior against them. You can model a battle pass, run a seasonal event schedule, test a gacha pull rate, or project how a new resource sink affects your economy over 30 days — and see it visually.

Best for: F2P economy design, LiveOps planning, balancing virtual currencies, battle pass design, game monetization design, progression systems.

Why it's different: It's the only tool in this list designed around the concept of a live game economy — not just static balance or abstract flows.

Try it: itembase.dev

LiveOps Planning Tools

Notion / Airtable

Most teams manage their LiveOps calendar in a doc or spreadsheet. Airtable is a step up — it adds views, filters, and relational data to what would otherwise be a flat calendar.

Best for: Event scheduling, content calendars, release planning.

Limitations: No simulation. You can plan an event in Airtable, but you can't test whether the economy impact of that event will cause inflation or kill your player retention.

itembase dev(LiveOps Simulation)

For designers who want to go beyond planning and actually test their LiveOps decisions before shipping, itembase lets you simulate the economy impact of an event. What happens to your premium currency supply if you run a double-drop weekend? What does a limited-time bundle do to your IAP conversion curve? These aren't questions a calendar tool can answer.

Best for: LiveOps economy modeling, event impact simulation, season design.

The Recommended Stack for Indie and Mobile Designers

Need	Tool
Game design document	Notion
UI / screen prototyping	Figma
Visual systems sketching	Miro
Static balance math	Google Sheets
Game economy design + simulation	itembase
LiveOps planning (calendar)	Notion / Airtable
LiveOps economy simulation	itembase

You don't need all of these on day one. But if you're building a F2P game with a virtual economy — any game with currencies, items, progression systems, or live events — you need something more than a spreadsheet. That's the gap itembase is built to fill.

Frequently Asked Questions

What is a game design tool?

A game design tool is any software that helps a game designer document, prototype, model, simulate, or communicate their game's design. This includes documentation tools (Notion), visual prototyping tools (Figma), systems modeling tools (Machinations), and economy simulation tools (itembase).

What tools do indie game designers use?

Most indie designers use a combination of Notion for documentation, Figma for UI, Google Sheets for balance math, and either Machinations or itembase for systems and economy work. The exact stack depends on the game type — economy-heavy games need dedicated economy tooling.

Is there a game design tool specifically for game economies?

Yes. itembase is purpose-built for game economy design and simulation. It's designed for designers working on F2P, mobile, and live games where virtual currencies, items, progression systems, and LiveOps events need to be designed, balanced, and tested together.

What's the best free game design tool?

For documentation, Notion has a generous free tier. For UI prototyping, Figma is free for individuals. For economy and systems work, itembase offers free access to start building and simulating your game economy.

Do I need a game design tool if I'm a solo developer?

Yes — arguably more than a team does. Solo developers can't rely on verbal alignment or shared context. A tool that makes your design visible and testable is what keeps your project from drifting as it grows.

Start Designing Your Game Economy

If you're building a game with any kind of virtual economy — currencies, items, progression, loot, events — try itembase. It's the game design tool built specifically for economy-heavy and live games.

Try itembase free → itembase.dev

I Shipped Two Web Games This Weekend — Here's the Stack

pickuma — Tue, 12 May 2026 08:30:21 +0000

Two new games live at play.pickuma.com: a single-button time-sense test called Stop at 7.77, and a third-person 3D-ish flight survival called Eagle Run. Both were built in a weekend on the same stack pickuma.com runs on. This is a quick writeup of why, what's in the box, and what surprised me.

The stack

Astro 6 (static output), Cloudflare Workers + Static Assets, Tailwind v4, vanilla JS for the game logic. No game engine. No state management library. No framework. Each game is one Astro page plus a single .js file in public/.

pickuma-play/
├── src/pages/
│   ├── index.astro        # game hub
│   ├── seven.astro        # Stop at 7.77 (45 lines)
│   └── eagle.astro        # Eagle Run (50 lines)
└── public/
    ├── seven.js           # 7.77 logic (~180 lines)
    └── eagle.js           # Eagle Run logic (~290 lines)

The hosting story is the same as pickuma.com: build to static, deploy to a Cloudflare Worker bound to a subdomain. play.pickuma.com is one wrangler deploy away from any change. SSL is free and automatic.

The thing I underestimated: the Cloudflare Custom Domain API for Workers. One PUT request and the subdomain was live with HTTPS in under a minute. No DNS records to fiddle with, no certificate dance.

Stop at 7.77

The whole game is: press start, then press stop when you think exactly 7.77 seconds have passed. Hard mode (default) hides the timer entirely — five bouncing dots tell you the game is running, but never how long you've been running. Easy mode shows a live counter.

The animation took longer than the game logic. The dots needed to feel alive without giving you a timing cue. A wave animation at 1.0 seconds per cycle would let you count it: tap on the eighth wave. So the dots bounce on an 830ms period with a 130ms stagger — irregular enough that you can't count them, smooth enough that they feel intentional.

Timing precision uses performance.now() directly. Sub-millisecond on modern browsers. The score is |elapsed - 7770| in milliseconds. World-record territory is under 30ms.

Eagle Run

Third-person view. You're an eagle in the middle of the screen, sky around you, ground grid sliding past below, obstacles flying toward the camera in 3D. Mouse steers, click adds permanent +0.15× speed. Survive as long as you can.

The rendering is pinhole projection on a 2D canvas. Each obstacle has world coordinates (x, y, z). To draw it, project:

const screenX = canvas.width / 2 + (worldX - eagleX) * (FOCAL / z);
const screenY = horizonY - (worldY - eagleY) * (FOCAL / z);
const drawSize = baseSize * (FOCAL / z);

That's the whole 3D engine. As z shrinks (obstacle approaches camera), the projected size grows; the same constant divisor produces both perspective and parallax. No matrix math, no shaders.

Four obstacle types: cubes (random Y), spheres (random Y), spikes (rise from the ground), rings (you can fly through the center; only the rim hurts you). Each spins on its own axis. Painter's algorithm sorts them back-to-front per frame.

The bald-eagle silhouette is bezier-curved paths with a 4.5Hz wing-flap oscillation. It looks more deliberate than the geometric placeholder it replaced.

What surprised me

Canvas 2D is fast enough for this. I was prepared to reach for WebGL or PixiJS. Didn't need to. A few dozen obstacles per frame with painter's-algorithm sort and gradient fills hold 60fps on a five-year-old MacBook. Pre-rendering star sprites to an offscreen canvas (instead of drawing a radial gradient per star per frame) was the only optimization that mattered.

performance.now() makes click-to-stop games feasible. Older browsers throttled it to 1ms or 100µs precision for security reasons. Current Chrome and Safari give you sub-millisecond on the main thread. That's the entire premise of Stop at 7.77.

SVG → PNG at build time is the right OG image strategy when you're static-hosted. No dynamic OG, no edge function gymnastics. @resvg/resvg-js renders a 1200×630 in a few hundred milliseconds. Wire it into the build script, ship it as a static asset, done.

What's missing

No global leaderboards yet — both games use localStorage for personal bests. Adding Supabase-backed leaderboards is a v1.1 task. No sound. No mobile-specific tuning beyond touch-as-mouse. No Poki/CrazyGames SDK integration; that's a separate build target for whenever the games are accepted.

Try them

Stop at 7.77 — press space (or tap) to start, again to stop. World record: under 0.030s off.
Eagle Run — move mouse to steer, click to accelerate. How long can you survive?

If you build something interesting on the same stack, send it. I'm always looking for what people are shipping on the small end of the indie scale.

I Built a Local-First VS Code Notes Extension with GitHub Sync

Rohan Vadsola — Tue, 12 May 2026 08:26:35 +0000

Most note-taking tools feel disconnected from actual development workflow.

I constantly ended up with:

debugging notes in random files
temporary snippets lost in chats
architecture ideas scattered everywhere
markdown files across multiple folders

So I built QuickNotes for VS Code.

It’s a local-first notes extension designed for developers.

Features
Markdown notes inside VS Code
Local private notebooks
Optional GitHub sync
Synced + local note spaces
Auto-sync support
Conflict-safe backups
Fast sidebar workflow

One thing I cared about a lot:
local notes stay local unless you explicitly move them to synced notes.

The goal was to make something simple, fast, and developer-native instead of another heavy productivity system.

Still improving it, but the first version is now live.

Marketplace:
https://marketplace.visualstudio.com/items?itemName=rohanvadsola.quicknotes

Would love feedback from developers using VS Code daily.