DEV Community: Neo Tang

Uwarp: 500+ Free Browser UI Tools (No Signup)

Neo Tang — Sat, 26 Sep 2026 13:08:32 +0000

Default design tools often mean installers, accounts, or uploading files to someone else’s server.

Uwarp is a free collection of 500+ browser UI tools—image and audio conversion, SVG, color, icons, mockups, and a few training games—meant to run locally in your tab. No signup for the tools themselves.

What you can do

A few examples from the homepage:

Colour Contrast Checker — live WCAG ratio for foreground / background pairs
Tints and Shades — build scales from any hex, export HEX / RGB / CSS / JSON
Free SVG Icons — search Material Icons, Font Awesome, Heroicons, and more
Image to Pixel Art — convert photos with grid size and palettes, download PNG
MP3 Cover Adder — embed album art and edit ID3 tags in the browser
GIF to Live Photo — turn GIFs into Live Photo–ready .mov without uploading

There are also lighter “recall” games (color, shape, sound) if you want a break that still trains visual / audio memory.

Built for makers, too

If you ship a product, submit a curated listing for manual review. Approved tools can show up as link-out pages under /curated. Free curated submission is open; paid featured placement is not for sale yet.

There’s also a separate hardware check playground at hardware-test.uwarp.design if you need quick browser device detection.

Try it

Site: https://www.uwarp.design
Submit a product: https://www.uwarp.design/submit

If a tool saves you five minutes, share it with a teammate—or star related open-source bits when you find them. Feedback welcome.

SVG Cursors You Can Actually Ship: Introducing `@sherotree/cursors`

Neo Tang — Sat, 26 Sep 2026 12:04:04 +0000

Default OS cursors are fine. For a product UI, they often feel generic.

I extracted the SVG hotspot cursors we use on Uwarp into a tiny MIT package: @sherotree/cursors.

What’s included

Four cursors with correct hotspot offsets baked into CSS:

default
pointer
grab
grabbing

Plus slightly smaller variants under a 1280px viewport width.

Install

npm install @sherotree/cursors

Global usage

import '@sherotree/cursors/style.css'

In Next.js App Router, import once from app/layout.tsx.

That sets body cursors, remaps common interactive selectors (a:hover, button:hover, [role=button], …), and overrides Tailwind’s .cursor-default / .cursor-pointer / .cursor-grab / .cursor-grabbing so those utilities keep the custom look.

Scoped usage

import '@sherotree/cursors/scoped.css'

<div class="sherotree-cursors">
  <!-- custom cursors only inside here -->
</div>

Jev Isn't a Chatbot — It's a System One Model for Typed Decisions

Neo Tang — Mon, 21 Sep 2026 15:56:54 +0000

If you've built agents in 2025–2026, you already know the awkward middle:

Hand-written if rules are too brittle for fuzzy judgments ("is this urgent?", "which team?", "is this tool call safe?").
A frontier LLM can answer those questions — but it's slow, expensive, and returns prose you still have to parse.

Jev (from TypeSafe AI) is aimed squarely at that gap. It doesn't write essays. It reads your program's state and returns typed, calibrated decisions your code can branch on immediately.

This post is a practical intro for indie / SaaS builders who want the mental model, a first API call, and a few real patterns — not a press release.

What Jev actually is

TypeSafe calls Jev a System One model.

Think Kahneman: System Two is slow, verbal reasoning (what chat LLMs imitate). System One is the fast gut check. Jev is built for the software version of that gut check — routing, scoring, filtering, gating — at high volume.

You send:

state — the context (ticket text, JSON event, agent messages, …)
questions — one or more typed questions about that state

You get back structured answers with probabilities. No free-text. No "sorry, as an AI…" preamble.

Training focus is RLCD (Reinforcement Learning for Calibrated Decisions): when Jev says ~80% confidence, the goal is that it's right about ~80% of the time. That calibration is what makes thresholds usable in production instead of vibes-based prompt engineering.

Three question types (that's the whole surface)

Type	What you ask	What you get back
choice	Pick 1 of up to 255 labelled options	Winning key + per-option probabilities + confidence
score	Place input on an ordered 2–10 level scale	Fractional score + distribution
noul	Yes/no as a probability	`noul` in `[0, 1]`

You can ask several questions in one request. They evaluate in parallel and share the state cost — so batching beats a loop of tiny calls.

Tiny example: urgency gate

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Hi, I'\''ve been trying to connect Stripe for 3 days and it keeps failing. I'\''m losing sales. Please help ASAP.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "The message conveys urgency or time-sensitivity"
      }
    }
  }'

A typical answer looks like:

{
  "is_urgent": {
    "type": "noul",
    "noul": 0.999
  }
}

Then your code stays boring (in a good way):

if (answers.is_urgent.noul > 0.7) {
  escalate(ticket);
}

No regex. No JSON-schema-from-an-LLM-that-sometimes-breaks. The type is fixed by the request.

Why this matters for agents (not just classifiers)

Agents spend most of their loop on tiny judgments:

Is this still needed?
Which model should handle this turn?
Is this tool call too risky?
Which queue should own this event?

Those used to be either brittle rules or another LLM round-trip. Jev is the middle lane: fast enough for the hot path, structured enough for code.

Public numbers TypeSafe / ecosystem write-ups commonly cite:

Latency roughly 70–500ms
Far cheaper than frontier LLMs on comparable classification-style tasks (pricing differs between direct TypeSafe access and hosted gateways — check the console you use)
Output tokens free on the decision API shape (you pay for input / state)

Use an LLM for generation and open-ended reasoning. Use Jev for the decisions around that generation.

Patterns that actually ship

1. Ticket / email triage

One state, multiple questions: route (choice), urgency (noul), lead quality (score). Auto-handle high-confidence cases; escalate the uncertain band.

2. Model routing

Ask Jev which tier should run this turn ("fast lookup" vs "architecture / high-stakes"). LangChain's experimental ModelRouterMiddleware is built around this idea.

3. Tool-call guardrails ("auto mode")

Before bash / delete / payment tools execute, ask a noul: "is this risky / irreversible?" Block or confirm when probability is high. Same pattern coding harnesses already use — now available as a cheap, open classifier layer.

4. Indie product glue

If you run SEO tools, support inboxes, or agent workflows (hello, build-in-public SaaS), Jev is a good fit anywhere you currently:

prompt an LLM just to get a label, or
maintain a growing pile of keyword heuristics

LangChain sketch

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke({
    "state": (
        "The deploy failed twice and customers are seeing 500s. "
        "Can someone look now?"
    ),
    "questions": {
        "urgent": Noul(instructions="Does this need attention right now?"),
    },
})

urgency = response.nouls["urgent"].noul

State can be text, structured data, or LangChain messages — handy inside middleware / nodes.

Ecosystem tips (beyond the core API)

The community moved fast after launch:

awesome-jev / jev-mcp style tooling around MCP clients
jevlang — Python "smart if" syntax for decision workflows
jev-router — route Claude Code / Codex turns to cheaper vs stronger models
browser / automation pilots that treat Jev as the chooser, not the writer

If you're exploring for a weekend project, start with one noul gate in an existing script. Don't rebuild your whole agent day one.

Practical gotchas

Pin model versions in production (jev-1.x.x) if thresholds matter — jev-latest can shift.
Batch questions on shared state instead of N sequential calls.
Use confidence / probability bands: auto-approve high certainty, human or LLM escalate the middle.
Jev is not a chat UX. Don't put it in front of end users as a conversational product. Put it inside the product.
Access paths vary (TypeSafe waitlist / console, gateways like OpenRouter / Vercel AI Gateway, or hosted metered keys). Pick one and keep the key server-side only.

Who's behind it (short)

TypeSafe AI was founded by Diogo Almeida (ex-OpenAI, co-inventor work around RLHF), with Erik Gafni and Sasha Sheng. The company came out of stealth in September 2026. The thesis is blunt: if AI is going to change work, people can't be the only consumers of intelligence — most of it should live quietly in software.

Bottom line

Jev won't write your README. It will decide, in under half a second, whether this ticket is urgent, which team owns it, and whether your agent should be allowed to run that delete.

For indie builders drowning in "tiny LLM calls that only return a label," that might be the most useful new primitive of the season.

Build UChart with KendoReact

Neo Tang — Sun, 23 Mar 2025 03:09:12 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built

UChart
Provides out-of-the-box chart templates and supports custom chart styles to help you quickly generate beautiful charts

Demo

Link: https://kendo.uwarp.design/
Repo:https://github.com/tangweikun/kendo

KendoReact Experience

I use the Checkbox,Splitter,TabStrip,TabStripTab,Button,NumericTextBox,Notification,NotificationGroup,Fade,Dialog,Label,Slider,Switch on the Uchart, help me quickly build the UI part. KendoReact is very easy to get started with, It took me almost no time to use it in my projects.

🏆 Pick Your Champion - Netlify Dynamic Site Challenge

Neo Tang — Sun, 12 May 2024 06:25:06 +0000

This is a submission for the Netlify Dynamic Site Challenge: Visual Feast & Build with Blobs & Clever Caching.

What I Built

Pick Your Champion is an interactive Quiz, player can pick the ideal type here.

Demo

🚀 Pick Your Champion

📸 Screenshots

Platform Primitives

Netlify Image CDN

Integrated Netlify Image CDN to dynamically manipulate images at the time of delivery.
Utilized parameterized transformation by adjusting parameters like width, height, quality, format, fit, and position in the image URL.

Netlify Blobs
Use it to store voting data.

import { getStore } from '@netlify/blobs';

export default async (req: Request) => {
  const { searchParams } = new URL(req.url);
  const gameId = searchParams.get('gameId');
  const roleId = searchParams.get('roleId');

  const store = getStore(`pick-your-champion`);
  const data = (await store.get(gameId, { type: 'json' })) || {};
  const preCount = data[roleId] ?? 0;
  data[roleId] = preCount + 1;

  await store.setJSON(gameId, data, {
    metadata: {
      lastModified: new Date().toISOString(),
    },
  });
  return new Response(data);
};

Netlify's fine-grained cache control capabilities

Implement custom Cache-Control headers, utilize the Netlify-CDN-Cache-Control header for edge caching, and demonstrate cache invalidation using cache tags.

First fetching timing cost

Fetching from the cache

Response Headers

Netlify's cache control capabilities is so good, make the API 10 times faster from the cache!!!

🎨 Logo Hunter - Netlify Dynamic Site Challenge

Neo Tang — Sun, 12 May 2024 03:55:18 +0000

This is a submission for the Netlify Dynamic Site Challenge: Visual Feast.

What I Built

Logo Hunter boasts a user-friendly interface that allows visitors to effortlessly find app logos from the App Store. At the same time, it was also released to the Figma plug-in community, designers can click the logo to place it in a Figma file.
The project utilizes Netlify's image CDN to fetch and optimize images dynamically. By applying resizing and format optimization, the project creates visually appealing galleries based on user input. This implementation guarantees efficient image delivery and a smooth user experience.

Demo

🚀 Logo Hunter

🎨 Logo Hunter in Figma

📌 Features

Find any app logo from the App Store by searching with keywords and filtering by country.
Transform the logo by adjusting parameters such as width, height, quality, format, fit, and position in the image URL.
You have the convenience of either downloading or copying the logo
Insert the logo to the Figma file

📸 Screenshots

Platform Primitives

Netlify Image CDN

Integrated Netlify Image CDN to dynamically manipulate images at the time of delivery.
Utilized parameterized transformation by adjusting parameters like width, height, quality, format, fit, and position in the image URL.

  const url =
    'https://uwarp.netlify.app/.netlify/images?url=' +
    artworkUrl512 +
 `&fit=${config.fit}&w=${config.size}&h=${config.size}&fm=${config.format}&q=${config.quality}&position=${config.position}`;

DEV Community: Neo Tang

Uwarp: 500+ Free Browser UI Tools (No Signup)

What you can do

Built for makers, too

Try it

SVG Cursors You Can Actually Ship: Introducing `@sherotree/cursors`

What’s included

Install

Global usage

Scoped usage

Links

Jev Isn't a Chatbot — It's a System One Model for Typed Decisions

What Jev actually is

Three question types (that's the whole surface)

Tiny example: urgency gate

Why this matters for agents (not just classifiers)

Patterns that actually ship

1. Ticket / email triage

2. Model routing

3. Tool-call guardrails ("auto mode")

4. Indie product glue

LangChain sketch

Ecosystem tips (beyond the core API)

Practical gotchas

Who's behind it (short)

Bottom line

Links

Build UChart with KendoReact

What I Built

Demo

KendoReact Experience

🏆 Pick Your Champion - Netlify Dynamic Site Challenge

What I Built

Demo

Platform Primitives

🎨 Logo Hunter - Netlify Dynamic Site Challenge

What I Built

Demo

Platform Primitives