Idiomatic hello-world programs and realistic snippets across sixteen languages, exercising comments, string escapes, interpolation, numeric literals, and language keywords — for testing syntax highlighters, editor themes, and tree-sitter grammars.
The classic hello-world in idiomatic Python 3, with a shebang, a module docstring, and the standard main guard — the minimal correct program for testing highlighters and interpreters.
A realistic Python snippet exercising type hints, an lru_cache-memoised recursive function, a generator, and a frozen dataclass — for testing syntax highlighters, linters (ruff/flake8), and formatters (black).
The classic hello-world in modern JavaScript — a minimal function calling console.log, for testing highlighters, Node, and JS parsers.
A realistic JavaScript snippet with an ES class, private #fields, arrow functions, template literals, a getter, and async/await — for testing highlighters, ESLint, Prettier, and bundlers.
The classic hello-world in TypeScript (shipped as .mts to avoid the MPEG-TS .ts collision) — a typed function for testing TypeScript-aware highlighters and the tsc compiler.
A realistic TypeScript snippet with an enum, a discriminated union, generics, exhaustive switch handling, and a typed reduce — for testing the type checker, highlighters, and the TS ESLint parser.
A minimal, valid HTML5 document — doctype, head, and a single heading — for testing HTML parsers, highlighters, and validators against the simplest well-formed page.
A realistic semantic HTML page with landmark elements (header, nav, main, article, footer), a figure with alt text and caption, and lists — for testing HTML parsers, accessibility tooling, and highlighters.
A minimal stylesheet that centres a heading with grid — the simplest useful CSS file for testing highlighters, CSS parsers, and minifiers.
A realistic component stylesheet using custom properties, flexbox, a fluid clamp() font size, color-mix(), a keyframe animation, and a media query — for testing CSS parsers, linters (stylelint), and highlighters.
The classic hello-world in Java — a public class with the standard main method — for testing highlighters, javac, and Java parsers.
A realistic Java class with a package declaration, fields, a nested record, methods that throw exceptions, and formatted output — for testing highlighters, javac, Checkstyle, and parsers.
The classic hello-world in C — an include, main, and printf — for testing highlighters, C compilers, and parsers against the canonical first program.
A realistic C program: a singly linked list with a typedef struct, malloc/free memory management, pointer walking, and error handling — for testing highlighters, compilers, and static analysers.
The classic hello-world in C++ — iostream and std::cout — for testing highlighters, C++ compilers, and parsers.
A realistic C++ snippet with a class template, STL algorithms (max_element, accumulate), std::move, and range handling — for testing highlighters, g++/clang++, and parsers against real templates.
The classic hello-world in Go — package main, an import, and fmt.Println, tab-indented like gofmt — for testing highlighters, the Go compiler, and parsers.
A realistic Go program: a worker pool with structs and methods, goroutines, buffered channels, and a sync.WaitGroup — tab-indented like gofmt, for testing highlighters, go vet, and parsers.
The classic hello-world in Rust — fn main and the println! macro — for testing highlighters, rustc, and parsers.
A realistic Rust snippet with an enum carrying data, a trait and impl, exhaustive match, iterators, and Option handling — for testing highlighters, rustc, clippy, and parsers against real ownership-era code.
The classic hello-world in PHP — an opening tag and echo — for testing highlighters, the PHP interpreter, and parsers.
A realistic modern-PHP snippet with strict types, a namespace, a backed enum, a final class with constructor-promoted readonly properties, and array_reduce with an arrow function — for testing highlighters, PHPStan, and parsers.
The classic hello-world in Ruby — a single puts — for testing highlighters, the Ruby interpreter, and parsers.
A realistic Ruby snippet: a Stack class that mixes in Enumerable, yields blocks, raises a custom error class, and uses string interpolation and symbol-to-proc — for testing highlighters, RuboCop, and parsers.
The classic hello-world in Bash — a shebang and echo, with LF line endings so it runs on Unix — for testing highlighters, ShellCheck, and shell parsers.
A realistic Bash script using strict mode (set -euo pipefail), functions, default parameters, a loop, and conditionals — an illustrative fixture (review before running) for testing highlighters, ShellCheck, and shfmt.
The classic first query in SQL — a single SELECT of a literal — for testing highlighters, SQL parsers, and query editors.
A realistic SQL script with CREATE TABLE constraints and foreign keys, INSERT seed data, a CREATE VIEW, and a grouped aggregate query with a join — for testing SQL parsers, formatters, and highlighters.
The classic hello-world in Kotlin — a top-level main function — for testing highlighters, the Kotlin compiler, and parsers.
A realistic Kotlin snippet with data classes, an enum, a sealed result interface, extension functions, and when expressions — for testing highlighters, the Kotlin compiler, ktlint, and parsers.
The classic hello-world in Swift — a single print — for testing highlighters, the Swift compiler, and parsers.
A realistic Swift snippet with an enum, a protocol, a struct with a computed property, optionals and optional binding, and higher-order functions — for testing highlighters, the Swift compiler, SwiftLint, and parsers.
Idiomatic C# hello-world for syntax highlighters and Roslyn-style parsers.
A small C# iterator Fibonacci utility — realistic snippet for language tooling.
Minimal Dart hello-world for Flutter/Dart IDE and highlight tests.
Tiny Dart class with a counter — fixture for Dart analysis servers.
Elixir module hello — for Beam/Elixir syntax and formatter smoke tests.
Elixir pipe-operator snippet for AST and formatter fixtures.
Zig hello-world for Zig language-server and highlighter tests.
Zig function plus a unit test stub — realistic small module.
Scala 3-style object hello for Scalac / Metals fixtures.
Scala foldLeft snippet for syntax and indexer tests.
Minimal Julia hello-world for syntax highlighters and Julia LSP smoke tests.
Julia typed Fibonacci with a for-loop — realistic snippet for language tooling.
Julia broadcast operators (.^ .+ ) for highlighter and parser edge cases.
Idiomatic Haskell hello-world for GHC / HLS fixtures.
Haskell foldl snippet for AST and highlighter tests.
Haskell Maybe pattern matching — realistic small module.
Minimal Lua hello for embedder and syntax-highlight tests.
Lua table with method colon syntax for parsers.
Tiny Lua coroutine yield loop for language tooling.
Minimal R hello-world for RStudio / language-server fixtures.
R data.frame construction — realistic snippet for R parsers.
R native pipe (|>) snippet for modern R tooling.
Minimal Clojure hello for CIDER / clj-kondo fixtures.
Clojure reduce utility — realistic snippet.
Clojure thread-first macro for highlighter tests.
Minimal Fortran 90 hello for gfortran / highlighter fixtures.
Fortran do-loop sum — realistic numerical snippet.
Fortran module with a pure-ish helper for module parsers.
Minimal Nim hello for nimlsp / highlighter tests.
Nim recursive fib proc — realistic snippet.
Nim object type plus proc — for Nim AST tooling.
Python dataclass SAMPLE for highlighter and type-checker smoke tests.
Tiny asyncio gather stub for async Python tooling.
Go generics helper for gopls / highlighter fixtures.
Rust Result map chain — realistic error-handling snippet.
TypeScript satisfies operator sample (.mts) for TS tooling.
Java record type hello for javac / highlighter fixtures.
Kotlin data class SAMPLE for Kotlin language-server tests.
Swift struct SAMPLE for SourceKit fixtures.
Ruby nested module SAMPLE for parser tests.
PHP 8 attributes SAMPLE for PHP tooling.
C struct SAMPLE for clangd / highlighter fixtures.
C++17 optional SAMPLE for clangd fixtures.
Bash strict-mode hello for shellcheck / highlighter tests.
SQL window function SAMPLE for SQL parsers.
C# LINQ chain SAMPLE for Roslyn fixtures.
Scala pattern match SAMPLE for Metals fixtures.
Zig errdefer SAMPLE for Zig language-server tests.
Dart async Future SAMPLE for analysis-server tests.
Elixir GenServer stub SAMPLE for Beam tooling.
Julia Macro SAMPLE for Wave G language-tooling coverage.
Haskell Typeclass SAMPLE for Wave G language-tooling coverage.
Lua Metatable SAMPLE for Wave G language-tooling coverage.
Nim Template SAMPLE for Wave G language-tooling coverage.
Intentionally lint-bait SAMPLE python snippet (unused-import-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE python snippet (bare-except-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE javascript snippet (var-shadow-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE javascript snippet (eqeqeq-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE typescript snippet (any-cast-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE go snippet (errcheck-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE rust snippet (unwrap-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE java snippet (empty-catch-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE ruby snippet (rescue-all-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE php snippet (error-suppression-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE shell snippet (unquoted-var-invalid) for rule-engine tests.
Intentionally lint-bait SAMPLE csharp snippet (empty-catch-invalid) for rule-engine tests.
A sample cache-first service worker handling install, activate, and fetch events with an offline fallback — for testing service-worker registration, JS parsers, and PWA tooling.
A one-line minified bundle built from two ES modules, ending in the `//# sourceMappingURL=` comment that points at the v3 map shipped beside it. For testing that a debugger, error reporter or bundler analyser follows the annotation and resolves the map relative to the bundle.
The same bundle with its v3 map embedded as a base64 data: URI in the sourceMappingURL comment - the single-file form dev builds emit. For testing that a tool decodes an inline map instead of trying to fetch it as a relative path.
A minified stylesheet closing with the CSS form of the annotation, `/*# sourceMappingURL= */` - the comment syntax differs from JavaScript's and is a common reason a CSS map is silently ignored. For testing stylesheet source-map resolution.
The terraform settings block: a version constraint range, two pinned providers, a local backend, default tags, and a second aliased provider configuration. The fictional examplecloud provider means nothing resolves to a real service.
Seven Terraform variables covering string, number, map and a map(object) with an optional attribute and a default, plus two validation blocks with error messages. The sensitive variable's default is explicitly a SAMPLE note, not a credential.
The resource graph: a network, a for_each subnet set, a counted instance resource, a data source, and a bucket on an aliased provider. Both repetition meta-arguments appear, plus lifecycle and an explicit depends_on edge.
The expression-heavy half of the stack: for expressions producing both a map and a filtered list, conditional expressions selecting whole objects, and a dynamic block that generates two firewall rules from a local list.
Three module calls covering the shapes a dependency grapher has to handle: a local path with explicit provider passing, a versioned registry source under for_each, and a count-gated conditional module.
Five Terraform outputs exercising a splat expression over a counted resource, a for expression over a for_each module, and a sensitive output that must stay redacted when propagated from a sensitive input.
A terraform.tfvars assigning the staging defaults, including a nested map-of-objects value. Pairs with the production overrides file, which replaces that map wholesale rather than merging into it.
The production tfvars overrides. Its point is a semantic that surprises people: a complex-typed variable is replaced whole, not deep-merged, so the staging app-b subnet does not survive the override.
A generic HCL2 image-build definition exercising the grammar rather than any vendor schema: labelled blocks, a list variable, locals, an indent-stripping heredoc with an interpolation inside it, and a for expression producing a list.
A deeply nested HCL2 job definition — job, group, task, service, check — with duration strings, a port mapping, and restart and update policies. Four levels of block nesting, which is where hand-rolled HCL readers usually break.
A generic HCL2 policy document with three severity-graded rules, condition blocks using all_of / none_of / one_of, and a dated exemption. Grants nothing to anything; it exists so policy tooling has a realistic document to read.
A three-stage Dockerfile with a syntax directive, build args interpolated into FROM lines, a heredoc COPY, multi-line LABEL and ENV continuations, a non-root USER, and HEALTHCHECK in exec form. Inert: every base image is a fictional example.invalid reference.
A Makefile whose recipe lines are indented with real TAB characters, as make requires. Covers simple, conditional, appended and substitution-reference variables, .PHONY, and .DEFAULT_GOAL. Every recipe is echo-only, so running it does nothing.
Pattern rules with the automatic variables $@, $<, $^ and $*, ifeq/ifdef conditional directives, a vpath search path, and a define block invoked through $(call). All recipe lines are TAB-indented and echo-only.
A Gradle Groovy DSL build script with a plugins block, a Java toolchain, five dependency configurations, task configuration via named() and a registered task. Every coordinate and repository is fictional, so nothing resolves.
A Gradle settings script — the file that actually defines a multi-project build — with pluginManagement, a repositories mode, a version catalog declaring libraries, a bundle and a plugin, and one project remapped to a custom directory.
A gradle.properties exercising the .properties grammar rather than Gradle: a \uXXXX escape, a backslash line continuation, all three key/value separator forms, and a key containing escaped separator characters.
The .properties edge cases collected in one file: both comment markers, empty values, a value whose trailing spaces are significant, unescaped = and : inside values, a # that is not a comment, escape sequences, an escaped space in a key, and a duplicate key.
A build-tool configuration in TOML, chosen for the constructs YAML has no direct equivalent for: three [[build.step]] array-of-tables entries carrying an ordered pipeline, a quoted glob key, and all three TOML date-time flavours.
We use Google Analytics and show ads via Adsterra. Non-essential cookies and ad scripts run only after you allow the matching categories. See our cookie policy.
