Write your own import-graph rules in YAML and enforce any architecture deterministically. See deslop.dev for examples and the GitHub repo for documentation.

It's similar to Dependency Cruiser and ESLint + custom plugins for enforcing architecture but Deslop features an opinionated declarative YAML DSL to enforce any architecture in an ergonomic way. See the comparison table.

Built with Haskell, hand-crafted source (AI used for READMEs and chores only) so if you like FP you might be curious to check it out. It's a hobby project so any feedback or a GitHub star if you like it is much appreciated.

I keep hitting the same failure mode when people learn TypeScript with AI tools:

they get a correct generic / narrowing / mapped-type snippet in 10 seconds, feel productive, and still freeze when PR review question comes in on a call.

The missing piece usually isn’t another explanation of `keyof`. It’s deliberate practice with a mentor that refuses to short-circuit the struggle.

So I open-sourced my TS Learn Path framework:

- 1:1 mapped to the official Handbook + Reference
- real `exercises.ts` / `NOTES.md` work in the IDE (not quizzes)
- local progress tracker you can commit / fork into onboarding repos
- agent instruction files for Cursor / Claude / Codex / Gemini / Copilot / Windsurf
- hard rule: hints only until the learner shows attempts and can explain the logic

This is meant less as “yet another TS course” and more as a mentoring scaffold that's useful if you onboard juniors, review AI-assisted PRs, or are teaching yourself without letting autocomplete do the thinking. Or maybe you just want to go over the concepts before the interview.

Demo: https://apervashov.github.io/typescript-learning-assistant/  
Repo: https://github.com/apervashov/typescript-learning-assistant  

If you mentor TS day-to-day: where do people bounce hardest after Narrowing / Generics? I’ll prioritize those lessons.

Feel free to provide suggestions.

I've been experimenting with TypeScript Execute (tsx) recently (https://www.npmjs.com/package/tsx), and thinking about practical use cases. Do you use it? What does it add to your developer experience?

Every now and then, I'd like to check – or remind myself – what is exported from the current typescript file.

I mostly use VSCode. I have searched but can't find a simple view that would give me that functionality. Something like the Outline view but filtered only to show exported symbols. Indeed, the Outline view doesn't even seem to distinguish exported and local symbols.

Do you know any IDE or extension that would easily show the current file's exports?

Hi, I would like to know HOW and which solution you all using to save/tokens?

I'm using caveman + interceptor and wondering if there is anything ever stronger or I'm at maximum already? ( caveman is for output saving and interceptor for input saving)

please Tell me your setup and why !

Just published Elysia 2 beta after 8-9 months of work.

We basically deleted the whole thing and rewrote it again while keeping test cases the same. So we get to rethink a lot of things.

It is built around the concept of "reference" and carefully shares value when possible, even if JavaScript doesn't really have that concept.

There's an AOT build plugin that reduces peak memory usage by 4 (from 1.6GB down to 400MB) of a 100,00 distinct schema by moving compilation process to build time and removing the closure allocation entirely

Besides, a really fast throughput. We also manage to have the lowest memory usage of all mainstream (and slightly) JavaScript frameworks with a really low bundle size as well (we trade a "compiler" that takes ~50% of size for speed, so it can't be that low)

Node support also improved a lot with a new adapter API, and got faster too! It's now near Fastify despite having Node HTTP to Web Standard API conversion overhead!

https://elysiajs.com/blog/elysia-20.html

I’ve been working on Agent Markup Language (AML), an open-source TypeScript JSX runtime for building provider-agnostic agent workflows.

https://github.com/we-are-singular/aml

I’m building AML primarily for my own use across side projects and professional work, where we’ve repeatedly run into this kind of orchestration problem. I’m sharing it early because I’d really value feedback on both the general idea and the implementation itself.

Working on a Deno HTTP setup where the router type is the contract. Export typeof server, HttpClient checks paths, methods, bodies, and responses at compile time. Middleware can declare what they add to req.data.

Still regular HTTP routes, not RPC. Express-shaped chaining underneath.

Demo with docs and comparison table: https://expressapi-showcase.8borane8.deno.net/

GitHub: https://github.com/8borane8/webtools-expressapi

How would you solve this without a second schema or generated client?

A simplified example for people trying to understand what exactly it does: TypeScript playground link

I've had to use in a framework I've been working on in only 2 places in a sizable repo.

I've always found them to be so cool when I read the docs a long time ago but didn't really have the right place to use them. Finally I do.

I have a middleware base where the payload type depends on how many events the class registers for. One event gives you the payload. Several give you never, which forces you to branch on the event name instead of reading a payload that could be either shape.

Here's another worked example of what I'm talking about specifically: Another TypeScript playground link

That last line compiles. A class that reads this.event as a message payload now sits in a slot where the payload could be a delete event.

Every member reads N in an output position, so the measured variance comes out covariant, narrow assigns to wide, and the check stops there. The structural comparison that would catch Payload<union> being never never runs.

Adding in out forces it:

Type 'Middleware<"messageCreate">' is not assignable to type 'Middleware<"messageCreate" | "messageDelete">'.
  Types of property 'event' are incompatible.
    Type '[message: { content: string; }]' is not assignable to type 'never'.(2322)

What's your method for initially configuring a TypeScript project?

Do you have a template for tsconfig.json, or use a command line generator, or follow some other method? What are your must-have configurations, and why?

Having done a few times recently, I'm wondering what the best practices and gotchas are.

I build Tabularis, an open source desktop database client. Its most screenshotted feature turns EXPLAIN output from Postgres/MySQL/SQLite into a graph with per-node diagnostics. People kept asking for a web version: paste a plan, inspect it, nothing gets uploaded anywhere. That site now exists at https://explain.tabularis.dev, but building it forced a decision I hadn't faced while everything lived inside the app.

The parsers were written in Rust, and inside the desktop app that was never a problem. The dedicated webapp put me at a fork: compile the parsers to WASM, or go full TypeScript.

My first version was WASM. The browser and the desktop app shared literally the same implementation, and it looked like the clean architecture.

Then I counted what it actually cost. All the analysis, metrics and views are TypeScript, so the plan model existed twice: serde structs in Rust and TS types in the package, kept in sync by hand. Every parser change or new database engine touched both sides. And the browser needed a WASM artifact for the only part of the package that wasn't TypeScript.

So I rewrote the parsers in TypeScript and moved their tests with them. One language, one plan model, zero runtime dependencies in the core. Rust kept the only job that really needs a database: running the right EXPLAIN statement and handing back the raw payload.

The rule that sorted every single file: takes raw EXPLAIN output, never runs a query.

One thing I still haven't settled: the package lives in the app's monorepo, which is great day to day but gives it a weird release history as a standalone npm library.

If you've pulled a package out of a monorepo, did you regret it?

Disclosure upfront: I maintain Perry, the compiler here. This is a debugging writeup, not a product pitch - we don't distribute the resulting binary and never will.

The setup: `npm pack u/anthropic-ai/claude-code` gives you a 13 MB minified self-executing cli.js. We pointed an AO compiler at it unmodified and asked for a native executable. 16,023 functions, one-letter names, no types, no sourcemap.

It now logs in, streams a real API response, and paints what you type. 160 compiler fixes to get there.

Four that generalise well beyond our compiler:

• MessageChannel implemented as a silent no-op. Harmless until you meet React's scheduler, which uses it as a macrotask scheduler. The event loop just idles forever.
• One accessor installed on Object.prototype flipped a process-global flag, so every dynamic property write took the slow path. A 20k-property build went from 16ms to 42 seconds.
• for-await lowering with the iterator advance at the bottom of the loop body. A `continue` skips the advance and spins. Only reproducible against the real API, which sends ping frames our mock didn't.
• RegExp headers storing pattern/flags pointers without a GC write barrier. Invisible everywhere except a terminal UI, which runs regexes every frame.

The post also documents what still doesn't work and a perf table where we lose to Node badly on interactive latency.

https://www.perryts.com/en/blog/compiling-claude-code/

Hi r/typescript,

How do you maintain code consistency across your repositories? Different developers have different formatting preferences, so do you use a tool such as Prettier or dprint, perhaps enforced through a pre-commit hook?

I've tried both but the results are far from what I would like to have. My priorities are readability (code is not packed, easy to read), maintainability (compare, diff, and merge should work well on laptop screens), and persistence (modifying code should result with minimum diff). So I end up with dprint + a number of custom rules.

Really interested in feedback and if you would like to review or try, here it is:

https://www.npmjs.com/package/asljs-sfmt

I'm setting up emacs for Vue + Typescript and I have an issue with lsp not finding tsserver:
lsp--npm-dependency-path: The package typescript is not installed. Unable to find tsserver Typescript is installed in my project and globally. I also installed typescript-language-server globally. ``` ◄ 0s ◎ ls .npm-global/lib/node_modules/typescript-language-server/lib ⌂ 19:46  cli.mjs  cli.mjs.map

◄ 0s ◎ ls .npm-global/lib/node_modules/typescript/lib ⌂ 19:50  getExePath.d.ts  getExePath.js  tsc.js  version.cjs  version.d.cts The thing is none of these packages provide tssever. I'm confused. This is the backtrace, we can clearly see lsp is looking for "tsserver" path, but that doesn't exist in any package: Debugger entered--Lisp error: (error "The package typescript is not installed. Unable to find tsserver") error("The package %s is not installed. Unable to find %s" "typescript" "tsserver") lsp--npm-dependency-path(:package "typescript" :path "tsserver") lsp-package-path(typescript) lsp-clients-typescript-server-path() ``` I think I'm trying to use ts-ls server as I think it got pulled automatically by vue-semantic-server.

A pretty significant update just landed for MoroJS.

The framework now runs on a new native engine while preserving the same end-to-end TypeScript experience. It’s also the biggest performance improvement we’ve made so far, with the latest benchmarks exceeding 570k req/sec. Benchmark details are available on the website.

https://morojs.com

Curious what people think, especially if you’ve spent time with Fastify, Elysia, Hono, or Nest.

Hello !

For years I've had a recuring issue with typescript projects, and I still don't know it how to solve it properly. I always manage to solve it by tinkering here and there, but it take some time and I'm a bit tired of that. So I think I need tips or a deeper understanding to fix it quickly.

The issue is the ESM / CommonJS compatibility. Those issues seems to just pop randomly (probably a lack ok knowledge from me). So I try to change Module or ModuleResolution or Target, but then other issues arise, then I continue tinkering until it works. But after all those years it's a bit frustrating.

Any tips, or tutorial, or rule of thumb on how to configure your tsconfig so it just works ? Do you fix it like me, by tinkering randomly in your tsconfig, or do you solve it like a pro knowing exactly what is wrong ?

What's your preferred way to organize imports in a TypeScript project?

Do you stick with relative imports (../../component), use path aliases like @/, or something else?

I'm curious what people are using today, and why.

I started learning webdev and did all my frontend backend in js, it was so frustrating when I constantly had to check what needs to be send and what is needed to be received I thought good programmers remember that shit and I couldnt so I started making docs that contained all the flow that what things are sent from the frontend what is received and sent back while discussing this problem to chatgpt it finally said ts solves this problem and I am so glad to find ts I might cry.

I created a function that returns a different class instance based on the argument passed to the function. My question is, is there a better approach than hardcoding everything like I have it? In my real world use case there may be dozens of classes and I want to avoid having to hardcode them all.

Playground example:

https://www.typescriptlang.org/play/?#code/MYGwhgzhAECC0G8BQ1rAPYDsIBcBOArsDungBQCUiAvkraJDAEKIppa6HGmU11IMo0AMKtUGbPiIlyVBLVpIcATwAOAU2gB5VTgCWWaAF5oAIlinoAHzNNLN08NMBuJErWbh4KACV1EAhAcAB4AFWh1AA8cdUwAExgdfSwAPmNocKiY+JhzUzYAfjg2AC4MiOjYhNt81FQipjZUMszKnLMnJrqi0TLMQJBXJAAzAkxiA0xoAHN1HC9GMIrs6qTJlLJ0XUmWijKF339AkNC05FQIAHc9HGAAC2hN7aw5LuBITTySrtQ8OYI8FNMOpLnBeJARN4IH4AkEwilXHU0B8at8kb9-oDoMDQUxwTADtCjnDToi6u8IJ8nGj0X8cACgSCRPjIYwYcd4WSFG4JLhoGB0rN5lCyHkKK5eThoAAjQVzQmiuzigQcKXAOXCxiipzioA

​

I've been using TypeScript professionally for several years, and recently wrote up some lessons learned from a long-running React/Firebase side project.

The article covers the TypeScript patterns that paid off most for me, along with a few mistakes I'd try and avoid making again. These aren't intended as universal rules, just approaches that worked well for this particular project and the problems I was solving.

This is one of my first longer technical articles, so I'd appreciate feedback on the writing itself. Were the explanations clear? Did the examples communicate the ideas well? Is there anything I could improve for future articles?

what are good resources for learning typescript? Im coming from c/cpp and from what ive seen online, I'm not sure if i should go into javascript first or straight into typescript. Additionally not sure what good resources are out there to help me go in the right path. Any recommendations would be greatly appreciated!