You know that feeling. You’re scrolling through a sleek new app on your $1,200 phone, and suddenly, the screen stutters. It hitches. For a split second, the smooth animation turns into a slideshow. It feels cheap. It feels broken. It feels like jank.
In the world of software development and user experience, jank is the ultimate vibe killer. It’s that jerky, stuttering motion that happens when a device can't keep up with the frames it’s supposed to be drawing. Most of us just call it "lag," but developers have a more specific bone to pick with it. If lag is the delay between you hitting a button and something happening, jank is the visual mess that happens while the thing is already in motion. It's the difference between a car taking five seconds to start (lag) and a car vibrating so hard the steering wheel shakes while you’re driving down the highway (jank).
The 60 FPS Holy Grail and Why We Fail It
Most modern screens refresh 60 times every single second. Some newer ones do it 120 times. To keep things buttery smooth at 60Hz, your computer or phone has exactly 16.66 milliseconds to figure out where every pixel goes and get it on the screen. If the processor gets distracted—maybe it’s busy loading an ad or crunching some heavy data in the background—and takes 20 milliseconds instead? Boom. You’ve dropped a frame. Your eye notices that missing frame instantly. That’s jank.
It’s subtle, yet infuriating.
Paul Lewis, a well-known Chrome engineer, spent years evangelizing the "RAIL" model (Response, Animation, Idle, Load). He argued that users perceive performance in very specific buckets. If an animation stutters, it breaks the illusion of a physical object moving under your thumb. We’ve become so accustomed to high-end hardware that any dip below that 60 FPS threshold feels like a personal insult from the software.
Where Does Jank Actually Come From?
It’s rarely one single thing. Software is a messy layer cake of code.
Sometimes, it’s the "Main Thread" being a hog. Imagine a kitchen where one chef has to take the orders, cook the steaks, wash the dishes, and plate the food. If the chef is busy scrubbing a heavy pan (processing a big JSON file), they can't plate the steak that's ready to go. The customer (you) sees the delay. In apps, the Main Thread handles user input and drawing the screen. When a developer asks the Main Thread to do too much heavy lifting, the screen stops updating.
Then you’ve got "Garbage Collection." Programs need to clean up memory they aren't using anymore. Languages like Java or JavaScript do this automatically. But if the "trash collector" decides to run right in the middle of your scroll animation, it pauses everything else. It’s like a janitor walking onto a basketball court mid-play to mop up a spill. The game stops. The players wait. You see jank.
Layout thrashing is another silent killer. This happens when a website tries to calculate the size and position of elements over and over in a loop. It’s incredibly expensive for the CPU. If you’ve ever been on a news site where the text jumps around as ads load, you’re witnessing a violent form of layout-induced jank.
✨ Don't miss: Bullets in the Gun: Why Everything You See in Movies is Probably Wrong
The Gaming Perspective: It’s Not Just About Frames
In gaming, jank takes on an even broader meaning. While techies use it to describe frame drops, gamers use "janky" to describe mechanics that feel unpolished or "glue-and-tape" systems.
Think about DayZ in its early years. The game was revolutionary, but climbing a ladder felt like a death-defying gamble. Your character might vibrate through the rungs or suddenly launch into the stratosphere. That’s mechanical jank. It’s when the physics engine and the player’s input aren't quite on speaking terms.
Path of Exile or Skyrim are often called janky, but often in a way that players find endearing—right up until it gets them killed. In these contexts, jank is the opposite of "polish." A game can run at 144 FPS and still feel janky if the animations don't transition smoothly or if the character’s feet slide across the floor like they’re on ice.
Why We Can't Just "Fix" It
You’d think with the sheer power of an M3 chip or a Ryzen 9, we’d be past this. We aren't.
Complexity scales faster than hardware. As our chips get faster, developers get more ambitious. They add more tracking scripts, higher-resolution assets, and more complex shaders. It’s an arms race where the user’s eyeballs are the collateral damage.
Also, the web is a nightmare of unpredictability. A developer might test their site on a $3,000 MacBook Pro and think it’s perfect. But when someone tries to load that same site on a budget Android phone with a weak processor and a spotty 4G connection, the experience is nothing but jank.
Optimization is hard. It’s boring. It doesn't show up in a marketing bullet point as easily as "New AI Features!" or "Now in 8K!" So, polish often gets left on the cutting room floor.
How to Spot Jank Like a Pro
If you want to see the "matrix" behind the stutter, most browsers have tools for this. In Chrome, you can open the Developer Tools, hit Cmd+Shift+P, and type "Show Rendering." From there, you can turn on a "Frame Rendering Stats" meter. It’ll show you a real-time graph of your FPS.
When that green line dips into the red? That’s the jank being quantified.
You can also look for "Layout Shifts." This is a big part of Google’s Core Web Vitals (specifically CLS, or Cumulative Layout Shift). If a button moves just as you’re about to click it because an image finally loaded above it, that’s a failure of performance. It’s a cousin to jank that actually hurts the usability of the internet.
Actionable Steps to Kill the Stutter
Whether you're a user tired of a slow phone or a dev trying to clean up an app, there are things you can do right now.
- For Users: Check your browser extensions. Honestly, half of the jank on the web is caused by poorly written extensions trying to "inject" code into every page you visit. Turn them all off and see if the web feels faster. It usually does. Also, restart your device. It’s a cliché for a reason—it clears out the "zombie" processes that are hogging the Main Thread.
- For Developers: Stop doing work on the scroll event. If you’re triggering heavy logic every time a user moves their mouse or thumb, you’re asking for trouble. Use
requestAnimationFramefor any visual changes. It tells the browser, "Hey, next time you’re ready to draw a frame, do this too," which keeps things synced up. - The Nuclear Option: If a specific app is consistently janky, check if there’s a "Lite" version or a web version. Sometimes the native app is just bloated beyond repair.
Jank is a reminder that our tech isn't magic. It's just a series of very fast calculations that sometimes trip over their own feet. We might never fully eliminate it, but understanding why it happens is the first step toward demanding better, smoother software. Don't settle for a stuttering scroll. If the hardware is capable, the software should be too.
The next time your screen hitches, you don't have to just get annoyed. You can point at it and know exactly what’s happening: somewhere, a main thread is gasping for air, a garbage collector is taking an ill-timed break, or a piece of code is trying to do 20 milliseconds of work in a 16-millisecond window.