New: the best keyboards for typing in 2026 - see our top picks
CheetahType
Web & FrontendDifficulty: Intermediate

JavaScript Typing Test

Master arrow functions, async/await pipelines, and ES6+ object destructuring.

10 Programming Languages & Syntax Targets

Choose Your Programming Language

Target the exact syntax, keywords, and reach patterns you use in your daily workflow.

JavaScript

Web & Frontend
Intermediate

Master arrow functions, async/await pipelines, and ES6+ object destructuring.

const fetchUserData = async (userId: string) => { const res = await fetch(`/api/users/${userId}`); return res.json(); };
Practice JavaScript

TypeScript

Web & Frontend
Advanced

Train generic types, interfaces, utility types, and strict type annotations.

type ApiResponse<T> = { data: T; status: number; error?: string; timestamp: Date; };
Practice TypeScript

Python

Data & Scripting
Intermediate

Master snake_case naming, list comprehensions, decorators, and colons.

def calculate_statistics(numbers: list[float]) -> dict[str, float]: return {'mean': sum(numbers) / len(numbers)}
Practice Python

C++

Backend & Systems
Expert

Drill template metaprogramming, scope resolution (::), pointers, and streams.

template <typename T> auto find_median(std::vector<T>& data) -> double { std::sort(data.begin(), data.end()); return data[data.size() / 2]; }
Practice C++

Java

Backend & Systems
Intermediate

Speed up verbose class declarations, Streams API, and Spring annotations.

public List<UserDTO> getActiveUsers() { return userRepository.findAll().stream().filter(User::isActive).map(this::toDTO).toList(); }
Practice Java

Rust

Backend & Systems
Expert

Build muscle memory for lifetimes ('a), match statements, Result/Option, and traits.

pub fn process_data<'a>(input: &'a str) -> Result<ParsedPayload<'a>, ParseError> { let payload = parse_raw(input)?; Ok(payload) }
Practice Rust

Go (Golang)

Backend & Systems
Intermediate

Speed up idiomatic error checks, goroutines, structs, and channel operations.

func FetchRecord(ctx context.Context, id string) (*Record, error) { row := db.QueryRowContext(ctx, query, id); return scan(row) }
Practice Go (Golang)

SQL

Data & Scripting
Beginner

Master uppercase keywords, complex JOINs, GROUP BY aggregations, and window functions.

SELECT user_id, COUNT(*) AS total_tests, AVG(wpm) AS average_speed FROM typing_tests GROUP BY user_id HAVING COUNT(*) >= 10 ORDER BY average_speed DESC LIMIT 50;
Practice SQL

HTML & CSS

Web & Frontend
Beginner

Speed up angle brackets, tags, attributes, CSS selectors, and flexbox properties.

<button class="btn-primary" aria-label="Submit test"> <span class="icon">⚡</span> <span>Start Racing</span> </button>
Practice HTML & CSS

Code Symbols & Operators

Syntax Drills
Expert

Drill tricky brackets, comparison operators, and pinky-stretching syntax keys.

({ [ < $val > ] }) => { return (a === b && c !== d) || (x >= y ?? z); };
Practice Code Symbols & Operators

C# / .NET

Backend & Systems
Intermediate

Master LINQ queries, async Task workflows, lambda expressions, and auto-properties.

public async Task<ActionResult<UserDto>> GetUserAsync(Guid id) => await _userService.FindByIdAsync(id) is { } u ? Ok(u) : NotFound();
Practice C# / .NET

PHP

Web & Frontend
Advanced

Train dollar signs ($), object arrows (->), double colons (::), and PHP 8.x attributes.

$users = User::where('active', true)->with('profile')->paginate(15);
Practice PHP

Ruby / Rails

Backend & Systems
Intermediate

Master Ruby blocks (do |x| ... end), symbols (:symbol), and expressive Rails syntax.

users.select(&:active?).map { |u| { id: u.id, email: u.email } }
Practice Ruby / Rails

Swift / iOS

Web & Frontend
Advanced

Practice Swift optionals (?, !), closures, guard let unwrapping, and SwiftUI views.

guard let url = URL(string: endpoint) else { throw NetworkError.invalidURL }
Practice Swift / iOS

Kotlin / Android

Backend & Systems
Intermediate

Train Kotlin null-safety (?. ?:), coroutines, data classes, and lambda extensions.

val user = repository.getUserById(id) ?: throw UserNotFoundException(id)
Practice Kotlin / Android

Bash & Shell Scripting

Data & Scripting
Advanced

Master pipes (|), redirects (>, >>), command flags (--verbose), and shell variables ($VAR).

find . -type f -name "*.log" | xargs grep -i "ERROR" | awk '{print $1, $4}' >> errors.txt
Practice Bash & Shell Scripting

GitHub README Dynamic Speed BadgeNew

Showcase your live CheetahType typing speed on your GitHub Profile README.

Live SVG Badge Preview
Live CheetahType Badge Preview

Auto-updates in real-time as you complete typing tests on CheetahType.

Markdown (for GitHub README.md)[![CheetahType Speed](https://cheetahtype.com/api/badge/developer?style=flat&theme=cheetah&stat=wpm)](https://cheetahtype.com/leaderboard)
HTML Tag (for Websites / Portfolios)<a href="https://cheetahtype.com/leaderboard"><img src="https://cheetahtype.com/api/badge/developer?style=flat&theme=cheetah&stat=wpm" alt="CheetahType Typing Speed" /></a>

Why Software Engineers Need Specialized Code Typing Practice

Most typing speed tests assess prose vocabulary: articles, common nouns, and simple punctuation. However, coding syntax has a fundamentally different physical profile:

01

Extreme Symbol Density

Code relies heavily on brackets ({} [] () <>), operators (=== => && ||), and punctuation that rarely occur in natural language.

02

High Shift-Key Load

Up to 65% of coding keystrokes require simultaneous Shift key combinations across opposing hands, demanding disciplined finger coordination.

03

Mixed-Case Identifiers

Identifiers like getUserProfileData or calculate_hash_sum force rapid micro-transitions between letter cases and symbols.

04

Zero Error Tolerance

In prose, a typo is a minor visual error. In code, a missing semicolon or unmatched brace breaks compilation and halts deployment.

About JavaScript Typing

Syntax characteristics, reach mechanics, and speed bottlenecks

JavaScript typing combines camelCase variable naming, rapid arrow function syntax (=>), template literal backticks, and nested object destructuring. Mastering JavaScript typing speed requires fluid left and right pinky reach for curly braces and parentheses.

Core Syntax Patterns Practiced:

Arrow functions (=>)Async / await & PromisesObject & array destructuringTemplate literals (`${var}`)Optional chaining (?.) & Nullish (??)

Syntax Reach Metrics

Difficulty RatingIntermediate
Shift & Symbol DensityHigh (~52% of keystrokes use Shift or Symbols)
Target ErgonomicsBalanced hand alternation, low wrist fatigue, and dedicated pinky anchors for brackets.

Finger Reach Breakdown for JavaScript

Optimal finger assignment for high-frequency operators and brackets

Symbol / OperatorAssigned FingerHandCommon Syntax Usage
=>Right Pinky & RingrightArrow function declaration
{}Right Pinky (with Shift)rightObject literals & code blocks
``Left PinkyleftTemplate literals & string interpolation
?.Right Pinky & RingrightOptional chaining property access
()Right Ring & PinkyrightFunction invocation & parameters

5 Practical Tips to Type JavaScript Faster

Actionable techniques for developers seeking maximum coding fluidity

1

Anchor your right pinky for instant access to quotes (', "), semicolons (;), and curly braces ({}).

2

Practice transitioning smoothly between the equals sign (=) and greater-than (>) for arrow functions (=>).

3

Use your left pinky for Shift when typing camelCase names that start on the right hand (e.g. getUserProfile).

4

Master backtick (`) typing with your left pinky without looking away from the screen.

5

Drill parenthesis pairs () immediately followed by curly braces {} for arrow callbacks.

Frequently Asked Questions

Practice Other Programming Languages

Rotate between different programming paradigms and symbol profiles to build well-rounded mechanical typing fluency.