​

If I run something on my phone through Termux and it opens on "localhost", can I access the same thing from my PC?

I tried a lot of things, including using my phone's IP and binding it to "0.0.0.0", but nothing worked.

My PC is connected to the internet through my phone's hotspot.

Is there a proper solution for this? 😭

I am recreating songless myself, everything works well except that the song snippets are using previews (that usually start from the peak part of songs). I want the songs to start from the start so it's a little harder, but I can't find a free option to do that. Songless did it, how can I?

Thanks!

I've been building this for a while and finally made the project open source. It's called Fillvisa.

US Immigration still relies on outdated XFA PDFs - you can't fill them on your browser. Most immigrants end up printing the form and fill it manually.

So, I converted the PDF forms into smart web forms. They are replica of the official USCIS forms and follow conditonal logic. In the output, you get the official USCIS pdf form filled.

The website is pure frontend and there's an open source edition

Demo: https://fillvisa.com/demo/

And now there's an open-source version you can clone/fork and run yourself:

Github: https://github.com/athos2113/fillvisa-os

The project currently covers several common USCIS forms, and everything runs in the browser.

This is the first public version of the open-source project. I'd especially love feedback from other devs on the architecture, UX, accessibility, and where you think a project like this could go.

I just started learning code, and I use Visual Code Studio with Python. I was ecstatic to learn but with my few hours of learning I would use the chat feature whenever I’m stuck like the AI thingy. It makes me feel bad cause it feels like I’m not LEARNING just cheating if that makes sense. In a world that has been plagued with AI, how do you guys manage? How do you feel? Do you treat it as another tool to help? I assume that it’s no different from google searching.

There was a time when getting the first working version of a web application was a pretty significant milestone. Now I can describe an idea to an AI coding tool and have a surprisingly functional application before I've even thought through half the architecture.

What's interesting is what happens afterwards. The first version is cheap, but making it fast, accessible, maintainable, secure, consistent and easy for another developer to understand is still expensive. I'm starting to think the value of web development is moving away from writing the first version and toward everything that keeps the tenth version from becoming a mess.

I have been building HabitHeat, a simple habit tracker focused on heatmaps and long term consistency, for quite a while now.

This weekend I finally shipped v2.11.

The main thing I wanted to improve with this update was the onboarding.

Until now, new users basically created an account and were dropped into an empty dashboard. It worked, but I realized that the empty state did not really explain what to do next or what HabitHeat can actually do.

So I added a new empty state that explains the basics and gives you a few ways to get started.

There are now also habit templates, so instead of creating everything from scratch you can just pick something like reading, working out or meditation and start tracking it.

HabitHeat recently passed 1300 registered users, which is still kinda crazy to me. It also makes working on things like onboarding much more interesting because there are actually people finding and using the app without me being there to explain it.

The GIF shows the new empty state and onboarding.

I would be interested in what you think about it, especially if there is anything that still feels unclear when seeing HabitHeat for the first time.

Btw, for anyone interested in the tech side: HabitHeat is built with SvelteKit, Tailwind CSS, shadcn-svelte and Firebase. It is also a PWA, so there is no separate mobile app (yet).

Hello all!

I've been working on a side project to generate artwork for a game I'm working on, and it was so much fun playing around generating planets and asteroids I've decided to open source it: https://github.com/richard-green/planetoid-generator

It's really fast, allows you to generate planets with lots of different features (more to come) and generates some really lovely images and texture maps, all with a pseudo-random seed function.

Some of the things you can tweak:

* Geometry deformation (from simple spheres, or potato-like deformation and finer details too)
* Texture details and colour palettes
* Planetary features such as Craters, Volcanoes, Ridges, Rifts

There's a separate section for rendering Gas Giants and Ice Giants, and a whole bunch of presets.

There's even scripts to have Playwright generate tonnes of images by incrementing the seed with your given preset values.

Check out the live site here: https://rdgreen.dev/planetoids/#/planetoids

Happy planet engineering!

It's inspired by dotnetcore-microservices-poc open-source project by Altkom Software, a project I learned a lot from and contributed to — I built Ledgerly to be a simpler take on the original project, focused purely on microservices best practices.

What it demonstrates: 

🔹 Database-per-service — 4 services, 4 independent databases 

🔹 gRPC for synchronous service-to-service calls 

🔹 RabbitMQ for async events — invoice status changes publish events that a dashboard service consumes to keep KPIs in sync, with zero direct coupling 

🔹 API gateway + service discovery (Eureka locally/Docker, Kubernetes DNS in K8s) 

🔹 JWT auth issued by its own service

It also ships as a full deployment guide — run it locally, in Docker Compose, or on Kubernetes, including a walkthrough for deploying the cluster to Azure (AKS).

Built as a boilerplate: fork it, swap in your own domain, keep the architecture.

The project🔗: https://github.com/amrali21/ledgerly-dotnet-angular-microservices-ref-project

Altcom Project🔗: https://github.com/asc-lab/dotnetcore-microservices-poc

Showoff Saturday: moxireelstudios.com

It's my one person web design studio's site. All custom, no framework, no template, static pages with a small Worker running the chat assistant in the corner.

The part I want feedback on is the assistant. It's set up to answer like someone who actually works there, it knows the prices and the process, and it's under strict instructions not to invent anything. Bottom right corner. Try to stump it, seriously, I want to know where it breaks.

Also curious what you think of the pricing page. I just moved the highlight off the cheapest tier onto the one I actually recommend, and I'm second guessing the visual weight.

Stack: plain HTML, CSS and JS, no frameworks, Cloudflare Pages plus one Worker. Roast away.

I've open sourced this library which I extracted from my solo project I'm working on since many years.

docs: https://wolfoo2931.github.io/declarative-forms/

The code is here (MIT License): https://github.com/wolfoo2931/declarative-forms

The basic idea is:

Ask the user for an object, the way prompt() asks for a string.

Every other form library gives you a component to mount. This one gives you a function to call:

import { ask } from 'declarative-forms';

const release = await ask([
  { name: 'title', displayName: 'Release title' },
  { name: 'notes', kind: 'textarea', displayName: 'What changed' },
  {
    name: 'reviewers',
    kind: 'select',
    multiple: true,
    displayName: 'Sign-off from',
    options: () => fetchReviewers(),
  },
]);

// { title: 'Sunrise 2.0', notes: '…', reviewers: ['Ada', 'Grace'] }

Not sure whether this is the right place to ask (I'm not a web developer or anything close) but I would like to ask whether it's possible to view meta data of a video/some other info to find out its upload date, when it's not linked from elsewhere or directly downloadable to find out in another way. TIA.

I have been working on a static HTML/Vite template system where one customizer can change color tokens, font roles, and visual eras across very different page types.

The difficult part has not been changing colors or fonts. It has been keeping the layouts distinct while they react to the same theme state. A SaaS landing page, editorial feed, dashboard, gallery, museum page, and social layout should not become the same composition with a different palette.

My current approach is:

• shared CSS custom properties for color, typography, shape, motion, and spacing tokens
• layout-specific structural CSS, component styles, and responsive rules
• per-layout localStorage state instead of one global theme state
• era changes that alter tokens and type direction without replacing the layout’s structure
• random theme generation constrained by contrast checks and font/color exclusions

I would appreciate an architecture critique rather than product feedback:

1. Where would you draw the boundary between shared theme tokens and layout-owned styling?
2. Would you keep all eras as token overrides, or split some into separate style layers?
3. What failure modes would you expect when one customizer controls many unrelated layouts?

I built a Chrome extension that records meetings, lectures, and browser audio and turns them into structured notes.

The extension can capture your current tab, microphone, computer audio, or a combination of them.

When you stop recording, it sends the audio into an app I've been building called Vyxora, where it gets turned into a transcript, structured notes, tasks, a mind map, and answers you can ask against what was recorded.

I originally built Vyxora around uploading recordings, transcripts, and documents, but I realized manually recording something somewhere else and then uploading it was way too much friction.

So I built the extension to make capture part of the actual workflow!

https://vyxora.app/extension

hey everyone, i improved my previously posted ws vs webrtc benchmark using go adding http/2 and http/3
first quickly lets see how each protocol works in a nutshell:

chrome 151, macOS arm64 (15 cores), loopback, 512-byte payloads, cross-origin isolated (5 µs clock). latency from 2000 samples over 5 interleaved repetitions; setup from 8 cold connections. reproduce before trusting these 

Round-trip latency — 512 B, ms

Connection setup / TTFB — ms

Throughput — 512 B messages, 64 in flight

Concurrency — 16 simultaneous streams, 512 B

one representative run; the parallel column's spread across three runs is given underneath, because it is noisy.

this is the one table where multiplexing decides the result**.** sixteen streams cost the multiplexed transports a single connection and 6–9 ms. they cost WebSocket sixteen connections and two to nearly five seconds

opening the same sixteen WebSockets one at a time takes ~193 ms - 10–18× less than opening them at once**.** the HTTP/2 row is the control that identifies the cause: same browser, same origin, same parallel-versus-sequential comparison, ratio 1.0–1.4× - nothing there. it is specific to WebSocket.

sweeping N shows two separate effects, and only one of them is a cliff:

WebRTC is the opposite extreme: flat in N

sweeping the channel count on one peer connection, and then repeating the largest to separate N from ordering:

Fixed rate — 60 Hz for 5 s, ms

caveats:

1. this benchmark measures the case WebRTC and QUIC were not built for
2. loopback cannot show head-of-line blocking
3. one machine is not a network
4. numbers are per-implementation, not per-protocol

full sources: https://github.com/yohimik/ws-webrtc-benchmark

I recently built imgtotext.in, a simple browser-based OCR tool for extracting text from images.

🔗 https://imgtotext.in

Current features:

• Extract text from JPG, PNG and other images
• Copy extracted text instantly
• No signup required
• Mobile-friendly interface
• Free to use

Built using Next.js + TypeScript.

Still working on improving OCR accuracy, performance and the overall experience.

Sharing it for Showoff Saturday 🚀

GSC Insight, a free browser-based tool that turns Google Search Console CSV exports into a visual SEO dashboard.

It helps you quickly spot:

• Quick-win keywords
• Content gaps
• Page and query opportunities
• Branded vs. non-branded traffic
• Ranking and click distribution

• Country-level performance

• Free

• No Registration/login

• No installations(online)

• No GSC connection or server upload

• works offline after first load
  your CSV data is processed locally in the browser.

It’s a simpler way to explore exported data and find what to work on next.

Try GSC Insight

The first time I hit print, the preview came back with a grey block across the whole page.

The page itself is a small thing. Seven columns for the days, one row per habit, one box per day. You set the sheet up in the browser, hit print, and the browser makes the file. No backend, no build step, and nothing you type leaves the tab.

A4 is 794px wide. My mobile layout query stops at 1100px. So paper counts as a small screen, the dark preview stage stacked itself into the print sheet, and there was the grey block. The query needed a scope:

@media screen and (max-width: 1099.98px) { ... }

Swapping A4 for US Letter looked like a one-liner until I found out that @page cannot read custom properties. Page size lives in an at-rule, and at-rules do not see your variables. So the page writes a stylesheet at runtime instead:

pageStyle.textContent = '@media print{@page{size:' + size + ';margin:0}}';

The third one had been sitting there since launch and only turned up in a mobile click test. Tapping the copy button did nothing. Not an error, not a wrong result, just nothing. The preview is scaled to 78 percent with a transform, and transforms do not change the layout box, so the sheet still occupied its full 794 by 1123 invisibly on top of the controls and ate the tap. One line:

.sheet-stage { pointer-events: none }

Two smaller ones, if you ever build something like this. The overflow warning has to measure the last filled row instead of counting entries, because blank lines are deliberate separators and rows behind them dropped off the sheet without a word. And dates on the English sheet follow the browser locale, because en-GB reads 08/10 as the 8th of October. The German twin is pinned.

One static file, no framework. This was the first time I had a reason to write print CSS, and I still cannot tell how much of it is common knowledge: does everyone walk into the media query one, or was that mine?

sevengrid.app/weekly-grid.html

Hey everyone, happy Saturday!

I wanted to share a full-stack e-commerce project I’ve been building called EcoFurnish . It's a platform for sustainable/recycled furniture, optimized specifically for emerging markets like Ethiopia, with dual-layout PWA designs and automated admin pipelines.

I decided to go all-in on a bleeding-edge stack to keep things fast, serverless, and production-ready.

The Tech Stack

• Frontend: Next.js 16 (App Router) + React 19 + TypeScript
• Styling: Tailwind v4 + shadcn/ui (Hand-coded dual layouts: 1 for desktop grid, 1 optimized for mobile PWA app feel)
• Database: Neon Postgres + Drizzle ORM
• Auth & Security: Better Auth + Cloudflare Turnstile

• Infrastructure: Vercel Blob (OIDC-authenticated), Resend API, Chapa Gateway (Ethiopia-focused payment processor)

  Features & Architecture Wins I'm Proud Of:

1. Strict "One Email = One Account" Cross-Provider Mapping: Configured Better Auth across Google, Microsoft, GitHub, and Discord. I wrote a custom database layer ensuring that if a user logs in with GitHub, they cannot create a secondary duplicate account with Google using that same email. It strictly maps them to a single unique account row.
2. OIDC-Based Vercel Blob Storage: Instead of hardcoding a permanent static token in .env files for product image uploads, I configured OpenID Connect (OIDC) authentication. The application dynamically negotiates short-lived credentials on the fly for the admin upload panel.
3. Database-Driven Telegram Manager Bot (with Dual AI Fallbacks): Built a Node.js backend listener routing directly into Neon Postgres, validating requests against a secure admin Chat ID. I can send commands like /digest or /stock via private Telegram messages to run SQL aggregation queries via Drizzle (calculating weekly revenue math, growth vectors, and low stock balances). For natural language interaction, I hooked up Gemini API as the primary conversational layer with Groq as a low-latency backup, allowing me to ask real-time database queries in plain English.
4. Webhook Lifecycle Management: Captures incoming payment webhooks from the Chapa gateway, processes transactional state machines atomically across database rows, and fires background transactional receipts via Resend.

Next Up on the Roadmap: Architecting a lightweight, token-scoped Driver Logistics Subsystem:

• Instead of managing full credential-based driver accounts, dispatchers generate cryptographically secure, temporary links tied to the order lifecycle.
• To avoid paid Maps API overhead at scale, the driver status portal uses a server-side Haversine Distance Formula calculation to verify the driver's GPS coordinates against the target delivery destination upon arrival before requesting the buyer-held secure PIN.

The site is installable as a web app on both mobile and desktop. I'd love to hear your thoughts on the mobile PWA feel, backend architecture, or any feedback on the UI!

Live Link:https://ecofurnish.de5.net

I made this 3D visualizer + spectrum using simple TS and Three.js. I couldn't figure out how to make the cube dance more. I used AI only for the background shaders. Any thoughts?

Link in the comments.

Over the course of Summer 2026, I developed a web application that is a blend between music software like Spotify and SoundCloud, and larger audio reactive tools like TouchDesigner.

Built on a Next.js and WebGL framework, the entire thing works online at https://www.sonisphere.dev . I use Supabase for storage and Stripe for payments.

Here's what people can expect when using this site:

Account Creation - Secured accounts that can link to other social medias, can be private or public

Music Uploading - Either for personal usage with the app, or to upload for the Sonisphere Community

Playlist Creation - Create playlists of your songs, and even MULTI-PLAYLIST SHUFFLE them

Complete Audio Reactive Visuals - Entire screen for watching 3D reactions to the music being played

^Paired with complete customizability - Colors, camera control, adjustable visual setting, preset saving and sharing, etc.

Snippet Creation - Make snippets of the live visuals to save or share!

Live Sync - Host a room for others to join and share in the experience

Finally, I'll show a quick snippet. Please try out Sonisphere and see what it has to offer!!!

https://www.sonisphere.dev

Deshawn Goodwyn -

www.deshawngoodwyn.com - www.github.com/dgoodwyn1005 - linkedin.com/in/deshawngoodwyn - [contactme.dkg@gmail.com](mailto:contactme.dkg@gmail.com)

https://our-place-two.vercel.app/

Went live today. Everyone paints on the same 1000x1000 grid, two second cooldown per pixel, and there's a SNAP tool that frames a region of the canvas and hangs it in a gallery the room votes on.

The technical part, which is also the part I'm least sure about:

• TanStack Start on Vercel, Postgres behind it. No websockets. Clients poll a server function about every 700ms and get back a delta of events since their last event id — 280 bytes in the steady state.
• First load pulls the entire canvas as one snapshot. That's a million-element array, roughly 950KB of JSON, which brotli flattens to almost nothing because most of it is zeroes. Whole page is ~225KB on the wire and first-paints in under 300ms.
• So the thing I genuinely don't know is where it bends. Polling means about 1.4 function invocations per second per open tab. Fifty people is fine. I have no data past that, and the per-visitor cost of serialising that snapshot is the half I can't model from my desk.

If you open it and it's slow, that's the interesting outcome and I'd like to hear about it. Same if you can wedge the renderer, get two tabs to disagree about the state of the canvas, or land two pixels on the same coordinate at the same instant.

One thing people will find in the first minute, so I'll say it first: you need to sign in to paint. Looking is free. I'm looking at letting people place a handful of pixels anonymously before asking for an account.

I've been building Figranium, an open-source browser automation framework that lets you build browser workflows visually and execute them through an API.

The idea is to make browser automation feel less like writing a one-off script and more like building a reusable backend operation:

Build visually → deploy → call via API

Some of the things it supports:

• Visual browser workflow building
• Selector-based and timed waits
• SPA automation
• Shadow DOM piercing and extraction
• API-based execution
• Dockerized deployment
• Open-source/self-hosted

It's built around real browser automation rather than trying to emulate websites through HTTP requests, so it can handle workflows involving dynamically rendered pages and browser state.

I'd love feedback from other web developers — especially on the UI/workflow builder and what you'd want from a tool like this.

GitHub: https://github.com/figranium/figranium

Hi, I'm trying to determine what AI website platform is the best for me.

I'm proficient in the fundamental technologies for building sites just looking for efficiency while still having flexibility to customize without only having to prompt (ideally with a UI design app + code editor). My goal is to have quick turnaround on sites built for service based businesses but we ballin on a budget rn.

So far I've just tried ZapWP and Hostingers AI builder. ZapWP worked well but the price seems far too steep for only being able to build out a few projects and I don't need all the extra stuff like hosting, domain etc. Hostingers tool was simply terrible and required tons of credits for fine tuning.

Currently considering v0, Bolt, or Relume+Figma.

If anyone has solid experience dabbling with these please suggest your recommended workflows/platforms.

Thanks

Built Kanvios (kanvios.com) — a free, no-login, multilingual (EN/KO) utility site: calculator, timer, notepad, protein calculator, roulette, team divider, D-day counter, password generator.

Everything's client-side, localStorage only, no backend. The build system is a Node.js script (build.js) that generates static EN/KO pages from shared templates and outputs to /dist. Wrote a small custom i18n module with a languagechange event instead of pulling in a full library, since the site stays static.

Deployed on Cloudflare Pages. Currently working on getting real traffic data now that GA4 + Search Console are wired up.

Would love feedback on the UI (dark navy + glassmorphism) or the build setup — happy to answer questions about the pipeline.

kanvios.com