Loading video...

Video Failed to Load

Go Home

5 cool sites for web developers – TypeScript table component - Next gen full-stack hosting (JavaScript, PHP, Python...) – Gradient SVG wave generator – Tiny useful dev tools – Open-source API testing client

27,099 views • 9 months ago •via X (Twitter)

0 Comments

No comments available

Comments from the original post will appear here

Related Videos

Adobe tried to buy Figma for $20 billion in 2022. The deal collapsed. So Figma went public on the NYSE in July 2025 instead. Ticker FIG. Public company. Quarterly earnings. Wall Street pressure. You know what happens to design tools after they IPO. In March 2025, Figma raised the Professional Full seat 33%. From $15 to $20 a month. Organization seats jumped to $55. Enterprise to $90. Then they took Dev Mode, which was free during beta, and locked it behind a paid seat. Your developers now pay extra to inspect the designs your designers already paid to create. In March 2026, Figma started charging for AI credits on top. If Figma raises prices again, you pay. If Figma gets acquired, you pray. If Figma shuts down, your files die with it. Your design system. On their servers. In a proprietary format only their app can read. To draw rectangles on a screen. There is an open source design platform that runs on your hardware. Stores your files in plain SVG. Costs $0 forever for unlimited users. It is called Penpot. 45,700+ stars on GitHub. A full Figma-grade design platform built on open web standards. Vector editing. Components. Design tokens to W3C spec. Flex and Grid layouts. Real-time multiplayer. Interactive prototyping. Here's what it does: → Real-time collaboration. Live cursors. Comments in line. → Components, variants, shared libraries. → Auto layout, Flex, CSS Grid. The tool outputs production CSS, not lookalike CSS. → Interactive prototypes with overlays, animations, and flows. → Inspect tab. Free. Built in. Every developer grabs production CSS, SVG, HTML without a separate seat. → Plugin ecosystem. Figma import to migrate your files. → Self-host on Docker in one command. Your designs never leave your network. Here's the wildest part: Figma stores your designs in a proprietary format only Figma can read. Penpot files are SVG. The same format your browser has rendered for 25 years. Open them in any editor. Open them in 20 years. Nobody can lock you out. The feature Figma charges your developers extra for, Penpot gives away. Without asking permission. Figma Professional: $20/month per seat. A 10-person team: $2,400/year. Figma Organization: $55/month per Full seat. A 50-person org: $33,000/year. Penpot: $0. Unlimited users. Unlimited files. Unlimited teams. Self-hosted. Free forever. 45,700+ stars. 2,700+ forks. 250+ contributors. MPL-2.0 license. Backed by a community that believes design tools should be free. Your designs. Your files. Your standards. 100% Open Source. (Link in the comments)

Nav Toor

216,943 views • 4 months ago

🚨BREAKING: An open-source agentic video production system just dropped. 11 pipelines, 49 tools, and a full product ad produced for $0.69 total. It's called OpenMontage. And it's not a text-to-video tool. It's a full production orchestration system where your AI coding assistant (Claude Code, Cursor, Copilot, Windsurf) becomes the director. Describe what you want in plain language. The agent researches, scripts, generates assets, edits, and renders the final video. Here's what the pipeline actually does: → Live web research first: 15-25+ searches across YouTube, Reddit, news sites before writing a single word of script → 12 video generation providers: Kling, Runway Gen-4, Google Veo 3, MiniMax, plus local GPU options (WAN 2.1, Hunyuan, CogVideo) → 8 image generation providers: FLUX, Google Imagen 4, DALL-E 3, Stable Diffusion locally → 4 TTS providers: ElevenLabs, Google (700+ voices), OpenAI, and Piper offline for free → WhisperX word-level subtitles burned in automatically → Remotion for React-based animated composition with spring physics, transitions, TikTok-style captions → Budget governance: cost estimate before execution, per-action approval above $0.50, hard cap at $10 Here's the wildest part: One product ad. 4 AI-generated images, TTS narration, royalty-free music, word-level subtitles, Remotion data visualizations. Total cost: $0.69. Zero manual asset work. Works with zero API keys too. Piper narrates locally, Pexels/Pixabay provide free stock, Remotion animates everything. No spend required to start. 100% Open Source. AGPL v3 License. (Link in the comments)

Guri Singh

112,201 views • 4 months ago

This Chinese guy created agents in Claude Code for MCP servers and single-handedly serves 6 marketing agencies a month from one iPhone, earning $5,000 from each. Inside he runs a pipeline of 7 agents on Claude Sonnet 4.6 that every Monday pulls a scan of the tech stack from a selected agency, develops an MCP server for its ad accounts, and over the course of a week brings it to production code ready to connect to Claude Desktop. No DevOps, no senior developer, no project manager. Just a Mac Mini in a work corner, an iPhone in the pocket, and a single API key. And traditional dev shops keep 5 people on project rates for the same contract, while his entire P&L is tokens, dirt-cheap hosting on Cloudflare, and Calendly. 7 agents run under a shared orchestrator-router and burn about 5 million tokens a day, which in the API bill comes out to $540 a month. The Mac Mini itself sits at home and keeps the entire orchestrator running 24/7, and from the iPhone the owner connects to it through a secure remote terminal and sees the output of any session right on the smartphone screen, wherever he happens to be. His starting system prompt looks like this: "you run a solo shop for custom MCP servers for marketing agencies. you hand out read-only tasks to 6 sub-agents and own all commits and shipping yourself. sub-agents: // Hunter (finds marketing agencies of 15 to 60 people that have no MCP access to Google Ads, Meta Ads, TikTok Ads, and HubSpot) // Mapper (pulls their tech stack, identifies 3 to 5 integration pains, and simultaneously writes the technical spec for the server: which tools, resources, and prompts to export through MCP, which auth flow and rate limit) // Coder (generates an MCP server in Python through the MCP SDK, deploys 8 to 15 tools for ad accounts and CRM) // Validator (connects the server to Claude Desktop, runs real client API keys in a sandbox, and checks for compliance with the MCP spec) // Shipper (writes a README, integration guide, deployment manual, packages the server, and hosts it on Cloudflare Workers or pushes to the GitHub of the client) // Mobile (always online on the iPhone, books demo calls in Calendly, picks up hot fixes, and confirms contracts through a secure remote terminal to the Mac Mini). only 1 owner agent works on 1 contract, no overlaps. you pull the owner out of observation mode only when a deal goes above $7,500 or the test coverage of the server drops below 85%." This prompt gives the system an understanding of its role and the limits of intervention from the very first line. It knows it is supposed to find agencies on its own. It knows it is supposed to bring every MCP server to production on its own. It knows it connects the live owner only on large deals or when the tests do not converge. → The pipeline runs without breaks, day or night → Hunter goes through about 130 marketing agencies on LinkedIn and Clutch per day → Mapper rolls out 4 audit reports with the tech stack and a final spec for each → Coder writes 1 to 2 MCP servers per week in Python with 8 to 15 tools → Validator validates every server through Claude Desktop with real client API keys → Shipper rolls out the full documentation package and pushes the finished product to Cloudflare Workers or the GitHub of the client And only when a contract breaks $7,500 or test coverage drops below 85% does the orchestrator pull the owner from whatever he is doing. And when the owner at that moment is behind the wheel or at a meeting in a coworking space, the Mobile agent in his iPhone picks up 1 contract in progress: confirms a meeting with the agency CMO in Calendly, opens a live demo of the MCP server through a secure terminal to the Mac Mini, and writes the test result to the shared state. The owner just swipes "approve" and in 15 minutes joins the Zoom demo. The fresh system log from last Wednesday looks like this: "hunter report: 132 agencies checked on LinkedIn and Clutch, 19 without MCP integrations, 8 with active requests for AI tooling in job posts, 4 with an open Q4 budget. passing to mapper." "coder: MCP server for Northwave Performance Marketing built in Python, 11 tools for Google Ads, Meta Ads, and GA4, 320 lines of code. exported to /Users/dev/mcp-shop/clients/northwave/server.py. validator connecting to Claude Desktop." "validator: 11 tools passed validation through Claude Desktop, test coverage 92%, average latency 380 ms. passing to shipper." "eval flag: contract with Pacific Reach Agency at $8,200 exceeds the approved limit of $7,500. sending for manual review." In his work setup there is no cloud server, no external team, and not even a separate office. At home sits a Mac Mini with a sandbox at /Users/dev/mcp-shop, on top runs an MCP router with a single API key to Claude, and the same key is forwarded to a secure terminal on the iPhone. Out of everything I have seen this year, this is the cleanest solo shop for custom MCP servers for marketing agencies: $540 a month on the API, about $30,000 into the account, and between them 7 system prompts, 1 Mac Mini in a work corner, and 1 iPhone that never leaves the pocket.

Blaze

55,926 views • 4 months ago

Use this prompt in OpenClaw to create your own AI agent command center that syncs up your life like Tony Stark's Jarvis in Iron Man. Adapt the specifics (agent names, data sources, branding) below to your own setup. Prompt: Build me a mission control dashboard for my OpenClaw AI agent system. Stack: Next.js 15 (App Router) + Convex (real-time backend) + Tailwind CSS v4 + Framer Motion + ShadCN UI + Lucide icons. TypeScript throughout. This is the command center where I monitor and control my autonomous AI agent(s) running on OpenClaw. The agent operates 24/7 on a Mac Mini, connected to Telegram/Discord, running cron jobs, spawning sub-agents, and reading/writing to a filesystem-based memory and state system. Dark mode only. Ultra-premium aesthetic, think Iron Man's JARVIS HUD meets a Bloomberg terminal. Subtle glass effects (backdrop-blur-xl, bg-white/[0.03]), no heavy gradients or glow. Rounded corners (16-20px on cards). Framer Motion for page transitions, stagger animations on card grids, spring physics on interactions. Mobile-first responsive. Never cookie-cutter. ## Architecture The dashboard reads live data from TWO sources: 1. **Convex**: real-time database for structured data (tasks, contacts, content drafts, calendar events, activity logs) 2. **Local API routes** (`/api/*`): read files from the agent's workspace filesystem at `~/.openclaw/workspace/` and return JSON. This is how live system state flows into the dashboard. ## Pages & Views (8 nav items, some with tab sub-views) ### 1. HOME (`/`) Dashboard overview. Grid of live status cards: - **System Health**: read from `/api/system-state` (parses `state/servers.json`). Show each service with UP/DOWN indicator, port, last check time. - **Agent Status**: read from `/api/agents` (parses `agents/registry.json` + agent workspace files). Show active agent count, healthy/unhealthy ratio, active sub-agent count from OpenClaw sessions API. - **Cron Health**: read from `/api/cron-health` (parses `state/crons.json`). Table of all scheduled jobs with name, schedule, last status (green/red dot), consecutive errors. - **Revenue Tracker**: read from `/api/revenue` (parses `state/revenue.json`). Current revenue, monthly burn, net. - **Content Pipeline**: read from `/api/content-pipeline` (parses `content/queue.md`). Kanban-style: Draft | Review | Approved | Published counts. - **Quick Stats**: total tasks, pending approvals, active sessions, uptime. All panels auto-refresh every 15 seconds. Live indicator dot + "AUTO 15S" badge in header. ### 2. OPS (`/ops`) with 3 tabs: Operations | Tasks | Calendar **Operations tab:** Full operational view. Server health table, branch status (from `state/branch-check.json`), observations feed (from `state/observations.md`), system priorities (from `shared-context/priorities.md`). **Tasks tab:** Strategic task suggestion system. API route `/api/suggested-tasks` reads/writes `state/suggested-tasks.json`. Cards grouped by category (Revenue, Product, Community, Content, Operations, Clients, Trading, Brand) with emoji headers. Each card shows title, reasoning, next action, priority badge, effort badge, approve/reject buttons. Filter bar by status and category. **Calendar tab:** Weekly calendar view from Convex `calendarEvents` table. Drag-to-create, color-coded by type, time slots. ### 3. AGENTS (`/agents`) with 2 tabs: Agents | Models **Agents tab:** Card grid of all registered agents from `/api/agents`. Each card shows name, role, model, level (L1-L4), status. Cards are CLICKABLE: expanding into a detail panel showing: - Agent personality (reads their SOUL .md) - Capabilities and rules (reads their RULES .md) - Sub-agents they can spawn - Recent outputs (reads from `shared-context/agent-outputs/`) **Models tab:** Model inventory table showing all available models, their routing (which tasks go to which model), costs, and failover chains. ### 4. CHAT (`/chat`): 2 tabs: Chat | Command **Chat tab:** Chat interface to communicate with the agent. Left sidebar shows session list (from `/api/chat-history` reading .jsonl transcript files). Main area shows messages with role-aligned bubbles (user right, assistant left), date separators, channel badges (telegram/discord/webchat). Input bar with send button + voice input (Web Speech API with SpeechRecognition). Messages sent via `/api/chat-send` which queues to a file the agent reads. **Command tab:** Quick command interface for common operations. ### 5. CONTENT (`/content`) Content pipeline management. Read from Convex `contentDrafts` table AND `/api/content-pipeline`. Show drafts in kanban columns. Each card shows title, platform target, draft text preview, status, created date. Edit/approve/reject actions. ### 6. COMMS (`/comms`) with 2 tabs: Comms | CRM **Comms tab:** Communication hub showing recent Discord digest, Telegram messages, notification history. **CRM tab:** Client pipeline kanban (Prospect → Contacted → Meeting → Proposal → Active). API route `/api/clients` reads markdown files from `clients/` directory. Each card shows client name, status, contacts, last interaction, next action. ### 7. KNOWLEDGE (`/knowledge`) with 2 tabs: Knowledge | Ecosystem **Knowledge tab:** Searchable knowledge base. Global search across all workspace files using `/api/knowledge` endpoint. **Ecosystem tab:** Product grid showing all products/apps in the ecosystem. Each card shows product name, status (Active/Development/Concept), health indicator, key metrics. Cards link to `/ecosystem/[slug]` detail pages with tabbed views (Overview, Brand, Community, Content, Legal, Product, Website, Actions). Detail pages read from `/api/ecosystem/[slug]` which parses workspace memory files. ### 8. CODE (`/code`) Code pipeline view. Shows repositories from `/api/repos` (scans ~/Desktop/Projects/ for git repos). Each repo card shows name, branch, last commit, dirty file count, language breakdown. Detail view at `/api/repos/detail` shows recent commits, file tree, open PRs. ## Navigation Top horizontal nav bar, NOT sidebar. All 8 items visible at all viewport widths. Use `flex` layout with `flex-1` items. Text size uses `clamp(0.45rem, 0.75vw, 0.6875rem)` for fluid scaling. Active item gets `text-primary bg-primary/[0.06]` static highlight (no sliding animation). Agent/app name visible at md+ breakpoints (`hidden md:inline`). Tab sub-views use a reusable `TabBar` component with pill/glass styling and Framer Motion `layoutId` transitions. Tab state stored in URL via `?tab=` search params. ## API Routes (all under `src/app/api/`) Each API route reads from the agent's workspace filesystem and returns JSON: - `/api/system-state` → reads `state/servers.json`, `state/branch-check.json` - `/api/agents` → reads `agents/registry.json`, agent SOUL .md files - `/api/agents/[id]` → reads specific agent's SOUL .md, RULES .md, outputs - `/api/cron-health` → reads `state/crons.json` - `/api/revenue` → reads `state/revenue.json` - `/api/content-pipeline` → parses `content/queue.md` (markdown with status markers) - `/api/suggested-tasks` → GET (read) / POST (approve/reject) on `state/suggested-tasks.json` - `/api/observations` → reads `state/observations.md` - `/api/priorities` → reads `shared-context/priorities.md` - `/api/chat-history` → reads .jsonl transcript files with pagination/search/channel filter - `/api/chat-send` → writes to queue file - `/api/clients` → reads markdown files from `clients/` directory - `/api/ecosystem/[slug]` → reads memory files for specific ecosystem - `/api/repos` → scans project directories for git repos - `/api/health` → returns status, uptime, memory usage, Convex connectivity All filesystem paths should be configurable via environment variable (default: `~/.openclaw/workspace/`). ## Convex Schema Define tables for: activities, calendarEvents, tasks, contacts, contentDrafts, ecosystemProducts. Include seed scripts (`convex/seed.ts`) to populate initial data. ## Key Design Rules - Mobile-first, test at 320px minimum - Font sizes 10-14px for body text, everything must fit naturally at small viewports - Cards use consistent border radius (16-20px) - Glass cards: `bg-white/[0.03] backdrop-blur-xl border border-white/[0.06]` - No heavy blur blobs or grain overlays - Stagger animations on card grids (0.05s delay per item) - Skeleton loading states for all async data - Custom scrollbar styling - Empty states with helpful messaging - All text must use Inter or system font stack - Never mix sharp and rounded corners in the same view - Premium = lighter feel, more whitespace, less visual noise ## File Structure ``` src/ app/ page.tsx, layout.tsx, providers.tsx agents/page.tsx calendar/page.tsx chat/page.tsx code/page.tsx comms/page.tsx content/page.tsx ecosystem/page.tsx, ecosystem/[slug]/page.tsx knowledge/page.tsx ops/page.tsx api/[...all routes above] components/ nav.tsx tab-bar.tsx dashboard-overview.tsx ops-view.tsx, suggested-tasks-view.tsx agents-view.tsx, models-view.tsx chat-center-view.tsx, voice-input.tsx content-view.tsx comms-view.tsx, crm-view.tsx knowledge-base.tsx, ecosystem-view.tsx code-pipeline.tsx activity-feed.tsx, calendar-view.tsx ui/ (ShadCN primitives) hooks/ lib/ convex/ schema.ts functions for each table seed.ts ``` Build the complete application. Every component, every API route, every Convex function. Production-quality code and premium design, not stubs. Dark mode only. Make it look incredibly beautiful and premium, no cookie cutter UI / AI slop.

klöss

201,608 views • 6 months ago

i cancelled $2,000/month in trading subscriptions replaced every single one with open-source repos here's the full stack: 1. TradingView Pro ($30/mo) → lightweight-charts 14K stars. by TradingView themselves. 45KB. free 2. Bloomberg Terminal ($2,000/mo) → fredapi + Claude every macro dataset the Fed publishes. free API 3. backtest platform ($100/mo) → prediction-market-backtesting NautilusTrader fork with Polymarket + Kalshi adapters 4. real-time dashboard → polyrec terminal UI: Chainlink oracle, Binance feed, orderbook depth 70+ indicators. auto CSV logging. strategy backtester 5. bot framework (7 strategies) → Polymarket-Trading-Bot 53K lines TypeScript. arbitrage, momentum, market making, AI forecast, whale copy-trade, convergence 6. strategy reverse engineering → polybot execution + market data infrastructure. paper trading Kafka, ClickHouse, Grafana. full analytics pipeline 7. paper trading for AI agents → polymarket-paper-trader real order books. exact fee model. slippage tracking your Claude agent gets $10K paper money and trades 8. token savings → rtk CLI proxy. cuts Claude Code tokens by 60-90% Rust. single binary. 10 AI tools supported 9. Claude Code itself ($200/mo) → goose 35K stars. by Block (Jack Dorsey). Rust works with any LLM. full agent loop. free 10. wallet tracking + copy trading → Kreo track top Polymarket wallets. auto copy trades the only tool on this list i actually pay for because it makes more than it costs total before: ~$2,600/month total now: $0 + Kreo bookmark this. you'll need it

self.dll

803,521 views • 4 months ago

20 GitHub repos with 2.4M+ combined stars that replace tools costing $60,000+/year 1. public-apis ⭐456k - 1,500+ free APIs across every category, weather to finance to games, all documented. 2. awesome-selfhosted ⭐312k - self-hosted replacements for Notion, Google Photos, Zapier, and dozens more paid subscriptions. 3. hermes-agent ⭐230k - self-improving personal agent with persistent memory, cron scheduling, MCP built in. Free alternative to paid always-on agent platforms. 4. n8n ⭐200k - visual automation with native AI agents. Replaces Zapier/Make entirely, self-hosted. 5. ollama ⭐178k - run Llama, Mistral, DeepSeek locally with one command. No API bill, no rate limits. 6. dify ⭐152k - visual builder for AI agents and RAG pipelines. Skip the $500/mo no-code AI builder subscription. 7. free-for-dev ⭐132k - hundreds of services with permanent free tiers. No trials, no credit card. 8. awesome-llm-apps ⭐132k - 100+ ready AI agents and RAG apps with full code. 9. awesome-mcp-servers ⭐92k - thousands of MCP servers connecting your agent to browsers, databases, anything. 10. supabase ⭐108k - Firebase alternative that's actually free to start. Auth, DB, storage in one Claude Code prompt. 11. strapi ⭐73k - open-source headless CMS, generates a full API from your content model in minutes. No Contentful bill. 12. immich ⭐110k - self-hosted photo and video backup with face recognition. Cancel the Google Photos storage plan. 13. appwrite ⭐57k - complete backend-as-a-service, self-hosted. Auth, DB, functions, storage, one prompt away from Firebase money. 14. medusa ⭐36k - full ecommerce backend, open source. Skip Shopify Plus fees entirely on your next vibe-coded store. 15. novu ⭐39k - notification infrastructure for email, SMS, push, in-app, all in one API. Replaces OneSignal's paid tiers. 16. tooljet ⭐38k - drag-and-drop internal tool builder connected to any database or API. Retool's seat pricing gone. 17. mattermost ⭐38k - self-hosted team chat built for engineering orgs. Slack without the per-seat bill. 18. outline ⭐40k - fast, clean team wiki and docs. Replaces Confluence and Notion's team plan. 19. plausible ⭐28.5k - privacy-friendly analytics, lightweight script, real dashboards. No GA360 contract needed. 20. openwork ⭐22k - open-source Claude Cowork alternative. Share skills and MCPs across Claude Code, Cursor, Codex, one setup for every agent. Save this before you pay for another tool this list already replaces for free 👇

unicode

34,375 views • 22 days ago

how to use firecrawl to give your AI eyes and actually build startups that outperform 99% of apps: 1. your AI is smart but blind. it can't go to a website, read a page, or grab data on its own. firecrawl fixes that. you put in a URL. you get back clean markdown, structured JSON, screenshots. feed it to any model. 2. three lines of code. that's it. no proxies. no anti-bot detection. no custom scrapers that break when a site changes. one API call. clean data back in seconds. works on 98%+ of sites. 3. firecrawl has six core capabilities: scrape a single page. crawl an entire site. map all URLs on a domain. search google and return full content. an agent endpoint where you describe what you want and it goes and finds it. and a browser sandbox where AI controls a real browser like filling forms, clicking buttons, handles logins. 4. the agent endpoint is wild. you can say "find all of YC's winter 24 dev tool companies and their founders and emails" and get back structured data. or "compare pricing tiers across stripe, square, and paypal" and get a side-by-side table. 5. the browser sandbox lets your AI stay logged in across sessions, navigate pagination, watch live as it browses. this is computer use without building the infrastructure yourself. 6. think of it in layers. every builder needs: an agent harness (claude code, cursor, codex), a search layer (perplexity, exa), a web data layer (firecrawl), an ops brain (obsidian, notion), and an outbound stack. the web data layer is the one most people are sleeping on. 7. this is the AWS moment for web data. in 2006 building a web app meant buying servers and managing racks. AWS said one API call, use our servers. some of the biggest companies of the last decade were built on that. firecrawl is doing the same thing for web data in 2026. 8. the framework i'd use for coming up with startup ideas building with clean data: take a massive horizontal platform. rebuild it for one niche using firecrawl. the vertical version always wins because people want specific, not generic. price for outcome. 9. a year ago firecrawl posted a job listing that said "please only apply if you're an AI agent." content creator agents. customer support agents. junior dev agents. it looked weird. it was a signal for where this is all going. the people who understand how to get clean web data, wrap it around an LLM, and package it as a product are the the ones with a 12-month head start. i use Firecrawl with Idea Browser . once you see what's possible with structured web data, you can't unsee it. episode is live on The Startup Ideas Podcast (SIP) 🧃 (full breakdown there) i tried to explain this as clear as possible for even the non technical. send it to a builder friend. watch

GREG ISENBERG

135,254 views • 5 months ago

GeoLibre v1.3.0 is here! GeoLibre is a free and open-source, lightweight, cloud-native GIS platform for visualizing, exploring, and analyzing geospatial data. One application that runs everywhere: in your web browser, as a native desktop app, on your phone, and inside a Jupyter notebook. No account, no server, no cost. Everything runs locally and your data stays private. This release packs in 50+ pull requests of new capabilities. A few highlights: - GIS in your pocket. A native Android build with offline tile caching and download-a-region support, so you can take your maps into the field with no signal. - AI, built in. A natural-language GIS assistant that turns plain-English requests into real geoprocessing, plus an AI segmentation toolbox powered by SamGeo and SAM 3 for extracting features from imagery. - Automate everything with Python. A full scripting API and an in-app Python Console, with new helpers for local rasters, choropleths, marker clusters, split-map comparisons, legends, and colorbars. - Map together, live. Real-time multi-user collaboration so you can open a project and edit the map with others at the same time. - Tell stories with maps. A scroll-driven story map builder and presenter that exports interactive narrative maps to standalone HTML. - A much bigger analysis toolbox. Reproject, explode, and aggregate tools, IDW and kriging interpolation, zonal statistics, a raster calculator, a Spatial Statistics toolbox, and network analysis with isochrones, service areas, and OD cost matrices, plus batch runs and model/pipeline chaining. - Smarter raster and SQL. Single-band pseudocolor classification, RGB band combinations, a no-backend client-side raster fallback, Apache Sedona as a SQL Workspace engine, and transparent S3, GCS, and Azure URL support in queries. - More ways to add, view, and share. New Shapefile and GeoPackage export, glTF/GLB 3D model layers, multi-provider batch and reverse geocoding, collapsible layer groups, and a macOS Homebrew cask. Try the live demo: Star it on GitHub: Docs and roadmap: Release notes: #GIS #OpenSource #Geospatial #MapLibre #WebGIS #Android #GeoLibre

Qiusheng Wu

18,075 views • 2 months ago

𝗖𝗵𝗶𝗻𝗮 𝗶𝘀 𝗳𝗶𝗻𝗶𝘀𝗵𝗶𝗻𝗴 𝘁𝗵𝗲 𝗵𝘂𝗺𝗮𝗻𝗼𝗶𝗱 𝗿𝗼𝗯𝗼𝘁 𝗿𝗮𝗰𝗲 𝗯𝗲𝗳𝗼𝗿𝗲 𝗺𝗼𝘀𝘁 𝗼𝗳 𝘁𝗵𝗲 𝗪𝗲𝘀𝘁 𝗿𝗲𝗮𝗹𝗶𝘇𝗲𝘀 𝗶𝘁 𝗵𝗮𝘀 𝘀𝘁𝗮𝗿𝘁𝗲𝗱. AGIBOT held its Partner Conference in Shanghai last week. The real headline wasn't the new hardware. It was their CTO standing on stage, telling investors that humanoid R&D season is over. 2026, he said, is "Deployment Year One." Not research. Not demos. Deployment into real factories, real warehouses, real stores. The manufacturing ramp is getting faster. 1,000 humanoid robots in the first 2 years. Another 4,000 in the next 12 months. Another 5,000 in just 3 months after that. AGIBOT is now shipping more humanoids per quarter than most US robotics companies have built in their entire existence. Then came the announcements the industry will spend the rest of the year reacting to. AIMA. The first full-stack open architecture for embodied AI. A unified robot operating system called Link-U, three dev platforms for motion, interaction, and task creation, plus an open agent framework. Any developer can build on top of it. This is the Android play for humanoids. GO-2. A vision-language-action foundation model with Action Chain-of-Thought reasoning. Planning and execution collapsed into one model. GE-2. A world model for simulation, strategy testing, and sim-to-real transfer. AGIBOT WORLD 2026. An open-source, production-grade real-world dataset pulled from actual industrial, logistics, hotel, and commercial sites. Seven standardized "productivity packages" covering logistics sorting, retail service, security patrol, commercial cleaning, and more. Plug, deploy, bill. A 5-year, $280 million commitment to seed a global developer and partner ecosystem. Now look at the competition. Boston Dynamics has been building humanoids since 1992. Tesla's Optimus is still climbing its own hype curve. Apptronik and Agility are well-funded but pre-scale on real deployments. AGIBOT has pulled all of this off in three years, with no acquisitions, no legacy platform, and no IPO distractions. While the West is still asking when humanoids will scale, China is already shipping them by the thousand.

Shruti

214,939 views • 4 months ago

What's next for OpenTUI? Here's a technical write-up. Over the last few months OpenTUI gained a lot of stability improvements, new unnecessary but fun features like live audio streaming, and useful features like rendering to the scrollback buffer mixed with a live TUI, called footer mode. Overall the feature set enables building large and complex applications. React and Solid make it super simple and convenient. There is still so much to do though. Three big milestones we have set out to achieve are: - Moving most of the behavioural logic currently living in TypeScript down to the native Zig core - Node compatibility - Optimizing the hell out of primitives like text rendering The render tree mechanisms are currently only usable from TypeScript. Think of the DOM, but controllable like a scene graph. Elements in the render tree are called renderables. They can expose a render method to draw themselves. All renderables are derived from a BaseRenderable. Renderables and the render tree will become native primitives. Building blocks usable from any language bindings. Reducing the TypeScript bindings to a very thin layer, with all the behavioural logic living in the native binary. Moving this down is not just a matter of porting TypeScript classes to Zig. TypeScript currently owns the tree, dirty-state propagation, layout reads, culling, and render ordering. If it still has to walk every node and call into native code for each step, we keep most of the complexity and add FFI overhead. Whole passes and their state need to move together. We took a big step towards this recently by building yoga-layout into the native binary. It exposes part of the official yoga-layout TypeScript package via FFI. Only the API surface that is actually used by OpenTUI. Covered by the test suite of the original yoga-layout package. This already gave a median speedup of ~2.5x, and up to 30x for narrow scenarios. The yoga-layout integration is useful beyond the speedup. Built-in text and editor measurement can now happen entirely in native code during layout instead of calling back into JavaScript. I ran an experiment last month taking this even further, having GPT 5.6 port yoga-layout from C++ to Zig, which gave extremely good results. It would be a burden to maintain right now though, so that's off the table for now. I might come back to it. Simon Klee is working relentlessly on Node compatibility and already has a full Node version of OpenCode running. Node got FFI support in v26.4.0, thanks to help from the Node community, namely Matteo Collina and Paolo Insogna. Behaviour and interfaces seem similar between Node and Bun, but there are some major differences. To get the best performance out of the Node FFI implementation, its usage has to follow some rules. Node has three ways to call native functions: the generic C++/libffi path, the SharedBuffer path, and the V8 Fast API. The generic path converts every argument in Node's C++ layer and then calls the function through libffi. It is flexible, but also the slowest option for frequently called functions. The SharedBuffer path is a middle ground. JavaScript writes scalar values and BigInt pointers into a small per-function buffer, reducing some conversion work. The actual native call still goes through libffi though. Typed arrays used as pointers cannot be packed into this buffer and fall back to the generic path. The path we really want is the V8 Fast API. Node generates a small machine-code trampoline for the exact function signature, allowing optimized JavaScript to call the native function without going through the generic converter or libffi. This only applies to JavaScript-to-native calls. Callbacks from native code into JavaScript still use libffi closures. Getting onto this path is quite strict. A signature can have at most eight arguments and everything must fit into CPU registers. x86-64 Unix systems have room for six GP (general-purpose) and eight FP (floating-point) arguments. AArch64 has room for seven GP and eight FP arguments. Anything that spills onto the stack falls back to a slower path. These are Node fast-path restrictions, not general FFI restrictions. Bun also does not support passing structs by value through its current FFI API. OpenTUI uses bun-ffi-structs to pack ABI-aligned struct data into an ArrayBuffer and passes a pointer instead. Despite the name, the package also works with Node. Pointers need some care too. Typed arrays and ArrayBuffers normally have to be resolved into BigInt addresses first. Eligible functions with exactly one pointer argument get another Fast API entrypoint that can extract the address directly from the buffer. An eligible signature is still not enough. V8 has to optimize a direct call with a fixed number of consistently typed arguments. Wrappers that collect arguments and forward them using spread or Reflect.apply can hide that call shape and keep the function on a slower path. The practical rules are: keep hot signatures within register limits, use direct fixed-arity calls with stable argument types, reuse owned buffers safely, and batch small operations. Then measure the real call site, because eligibility only makes a function fast-capable. We have to design the ABI around these constraints where it makes sense and gives the expected performance improvement. The third big area is text rendering. Today a Text renderable accepts a string, StyledText, or a tree of TextNodes. Before rendering, the TextNode tree is walked and flattened into styled chunks. Those chunks are packed in TypeScript, sent through FFI, copied into a native TextBuffer, and stored in a rope. Styles are represented separately as highlights. A TextBufferView then wraps the rope into visual lines, which are drawn into the visible buffer. This works, but updates are much more expensive than they should be. setStyledText effectively throws away and rebuilds the rope, copies and reparses all text and recreates the style highlights. Changing one TextNode also walks and flattens the complete tree before going through this path again. Text and style segments should instead live directly in the rope and support incremental replacement. Memory ownership is split between retained JavaScript buffers, the native memory registry, rope arenas, wrapping caches, styled-text storage, and highlights. Different operations preserve or reset different parts of that state. This is hard to reason about and can retain memory for much longer than expected. Text storage needs clearer ownership, with fewer lifetimes split across JavaScript and native code. The public API reflects the same split. The t template literal is convenient, but creates another intermediate chunk representation that is mutable, not cached, and not merged. Text also maintains both StyledText content and a special TextNode tree, which do not compose properly. TextNode is only a style scope, not a normal layout primitive, so Text renderables cannot naturally compose inside each other. I think this should become one Text primitive backed directly by rope segments. The template literal API might disappear or become a very thin helper around those native segments. Editing has another temporary layer in TypeScript. Extmarks currently monkey-patch editing operations, scan and adjust all marks after changes, maintain their own undo state, and recreate native highlights. They should become native marks anchored directly in the rope. A proper mark tree, similar to Neovim's marktree, could update marks together with edits, undo, and redo, and provide the foundation for highlights and concealment. Text wrapping has also become too complex. Supporting CJK, emoji, combining characters, ZWJ sequences, tabs, and different terminal width rules currently mixes byte offsets, grapheme indexes, and display-cell columns across several custom algorithms. Dirty views rewrap the complete document. Measurement and drawing can repeat some of the same work. The wrapping implementation needs an overhaul, but the exact shape is still open. The goal is to make Unicode handling easier to maintain, avoid repeated full-document work, and clearly separate byte offsets, graphemes, and terminal display cells. None of this will happen as one big rewrite. We will replace pieces when we understand the problem well enough and when the result is clearly simpler, faster, or more useful. To achieve all of this we might break public interfaces. Thanks to OpenCode and a lot of good models, migration to a new version with breaking changes mostly is not an issue anymore. What do you want to see next for OpenTUI?

kmdr

29,430 views • 1 month ago

10 free github repos that can replace major SaaS with subscriptions. all free. open-sourced. some are MIT licensed. — 1️⃣ openscreen — replaces screen studio ($29/mo) - a clean macOS/windows/linux screen recorder for polished demos. - blur, cursor highlighting, annotations, export to mp4 or gif at any aspect ratio. - doesn't try to clone every feature, just nails the basics for quick walkthroughs you'd post on X. — 2️⃣ voicebox — replaces elevenlabs ($22/mo) + wisprflow ($15/mo) - local-first AI voice studio. - clone voices from 3 seconds of audio, generate speech across 7 TTS engines in 23 languages, - dictate into any text field with a global hotkey. - nothing leaves your machine. - runs on apple silicon, cuda, rocm. — 3️⃣ openshorts — replaces opus clip ($19/mo) + submagic ($16/mo) - free AI video platform. - clip generator turns long youtube videos into 9:16 shorts with auto-subtitles and face tracking (runs on free gemini + elevenlabs tiers). - also includes AI UGC video generation with actors — that part is pay-per-use via fal. ai (~$0.65-2 per video). docker self-host. — 4️⃣ freellmapi — replaces chatgpt pro + claude pro ($20/mo each) - stacks 14 free AI provider tiers (google, groq, cerebras, openrouter, github models + 9 more) behind one openai-compatible endpoint. ~800M tokens/month. - smart router with failover, sticky sessions, encrypted key storage. ships with a dashboard. — 5️⃣ playwright-mcp — replaces browserbase ($39/mo) + browser use ($25/mo) - microsoft's official MCP server that gives any AI agent full browser control. - uses accessibility trees, not screenshots — deterministic and token-efficient. - works with claude code, cursor, windsurf, codex out of the box. — 6️⃣ vibe-trading — replaces tradingview premium ($60/mo) - natural-language finance research agent. - 7 backtest engines across stocks, crypto, futures, forex. - 75 specialist skills (factor analysis, options strategy, ML strategy). - 29 multi-agent swarm presets. - 21 of 22 MCP tools work with zero API keys. — 7️⃣ CalCom — replaces calendly ($12/mo) + savvycal ($12/mo) - the open-source scheduling infrastructure. - one-on-ones, group events, round-robin, team booking, - payment collection (stripe), routing forms, workflows. - integrates with google/outlook/apple calendar, zoom, meet, teams. - self-host in 10 minutes with docker. 40k stars. — 8️⃣ whisper — replaces otter ($17/mo) - openAI's open-source speech-to-text model. - transcribe audio in 99 languages, translate to english, generate timestamps. - runs locally on cpu or gpu. - the actual model behind most "AI transcription" SaaS tools you're paying for. — 9️⃣ postiz — replaces buffer ($15/mo) - AI-powered social media scheduler. - cross-post to X, linkedin, instagram, tiktok, threads, bluesky, mastodon, youtube, pinterest. - AI captions and hashtags. - analytics dashboard. team workspaces. 31k stars and rising. — 🔟 vaultwarden — replaces 1password ($8/mo) - unofficial bitwarden-compatible server written in rust. - works with every official bitwarden client (mobile, desktop, browser). - unlimited users, unlimited vaults, full enterprise feature set. - runs on a $5 VPS or your home server. — disclaimer: open-source ≠ 1:1 replacement. you'll trade polish for ownership, hand-holding for control, and a credit card for a github version. for builders, prototypers, and indie hackers — that's the whole point. for everyone else, the paid tools still have their place. bookmark this. share with one friend bleeding subscription fees. ~m0h

m0h

253,313 views • 3 months ago

GeoLibre v2.3.0 is here! GeoLibre is a free and open-source, lightweight, cloud-native GIS platform for visualizing, exploring, and analyzing geospatial data. It runs everywhere you do, in the web browser, on the desktop, on mobile, and inside Jupyter notebooks, all while keeping your data local and private. This release brings a legend that writes itself from your symbology, a new GeoLens catalog browser, and 200+ GeoLibre Rust geoprocessing tools running entirely in the browser. What's new in v2.3.0 - Automatic on-map Legend: the legend builds itself from your visible layers, with class rows for graduated, categorized, rule-based, and expression styling, gradient bars for heatmaps and raster colormaps, and land-cover labels from a Raster Attribute Table. Rename, hide, reorder, or add your own entries, and it saves with the project. - Symbology swatches in the Layers panel: every row shows a dot, line, square, or image glyph in the layer's own color, so a tall layer stack reads at a glance. - GeoLens catalog browser: connect to a self-hosted GeoLens server, search its catalog, and add datasets as vector tiles, GeoJSON, or rendered raster tiles. - Emerging Hot Spot Analysis: build a space-time cube from timestamped points and classify every cell as a new, intensifying, persistent, diminishing, sporadic, oscillating, or historical hot or cold spot, all client side. - Mosaic time series: the Time Slider now steps through MosaicJSON and STAC collections of many COGs per date, on either a GPU or a WASM rendering engine. - Copy and paste layer styles: give a whole set of layers one consistent look without restyling each in turn. - Shareable tool links: deep-link any Whitebox tool with a ?tool= URL that opens the dialog preselected and pre-fills the form, with a Copy link button to build it for you. - Smarter data loading: pick which layers to load from a multi-layer GeoPackage, import CSVs whose coordinates are in any projected CRS, and read a raster's real CRS, pixel size, and extent from the metadata dialog. - Multiple AI profiles: define several provider, model, and credential setups, pick a default, and switch between them from the assistant panel. Try it out - Launch GeoLibre Web: - GitHub: - Documentation: - Release notes: #GIS #Geospatial #OpenSource #RemoteSensing #MapLibre #GeoLibre

Qiusheng Wu

293,227 views • 1 month ago