spark.lucko.me

What is spark?

spark is a performance profiler for Minecraft clients, servers, and proxies. It watches how the game or server actually behaves at runtime and turns that into data you can read: where time is being spent, what is eating memory, and how performance changes over time.

It has three main jobs, all described on the site:

• Profiler – diagnoses performance problems and bottlenecks, so you can see which code or systems are slowing things down.
• Memory inspection – produces full heap dumps and summaries of what is using the most memory, and monitors garbage collection activity.
• Health reporting – tracks key metrics so you can follow performance trends rather than only a single snapshot.

The site itself is also a viewer for that data. You run the appropriate spark commands in-game or on the server, upload the result, and open the generated link. Alternatively you can export a .sparkprofile or .sparkheap file and drag it into the viewer page; only those two file types are accepted. The viewer is written in JavaScript with React and is open source.

Who it is for: server owners and admins chasing lag or tick spikes, modpack and plugin developers checking whether their code is the cause, and anyone who needs to hand a readable performance report to someone else. The viewer matters because raw profiling output is hard to interpret; a shareable link or file makes it a team activity.

A practical next step: if a server is lagging, decide first what question you are asking. Suspect slow code or a specific plugin? Take a profile. Suspect memory pressure or GC pauses? Take a heap summary. Then open it in the viewer and compare against a baseline captured when the server was healthy — a single profile tells you what happened once, while health reporting over time shows whether a change actually helped.

How do I install spark on my Minecraft server?

Installing spark means adding its plugin/mod to the server, then confirming it loaded. spark is a performance profiler for Minecraft servers, clients and proxies, and the official site points you to a Downloads page and Documentation for the current version and setup steps.

The exact file and folder depend on your server type, so use the documentation rather than guessing:

• Plugin servers (Paper, Spigot, Purpur, etc.): download the plugin build, drop the .jar into your server's plugins folder, and restart the server.
• Modded servers (Fabric, Forge, NeoForge): install the matching mod build into the mods folder. On Fabric/Quilt you typically also need the Fabric API.
• Proxies (Velocity, BungeeCord, Waterfall): install the proxy-specific build into the proxy's plugin folder.
• Clients: a separate client mod build exists if you want to profile your own game.

After restarting, run a spark command such as /spark (or /spark profiler) in chat or console. If it responds, the install worked. If the command is unknown, the file is usually in the wrong folder, built for the wrong loader, or the server wasn't fully restarted.

A practical first test: run /spark profiler start, let it capture for 30–60 seconds while the lag occurs, then /spark profiler stop. spark uploads the result and gives you a link that opens in its online viewer at spark, where you can inspect the data. You can also export a .sparkprofile or .sparkheap file and drag it into the viewer later, which is handy for sharing with a server admin or developer.

For version-specific download links and command syntax, start at spark and follow its Documentation and Downloads sections.

How do I read a spark profile to find what's causing lag?

Reading a spark profile means finding which code paths consume the most server time, then narrowing from broad categories down to the specific plugin, mod or vanilla mechanic responsible. The viewer at spark is where a .sparkprofile is opened and interpreted.

Start with the biggest number, not the prettiest chart

Open the profile and look at the main call tree or the top-level breakdown first. Ask one question: which single branch accounts for the largest share of tick time? Typical answers fall into a few buckets — entity ticking, chunk/block work, plugin event handlers, or async tasks. Ignore anything under a few percent until the top item is understood; a profile is a ranking, not a full inventory.

A concrete scenario

A server owner notices the tick rate dropping to 12 TPS once 30 players are online. They run a timed profile during the worst period, open it in the viewer, and see one plugin's PlayerMoveEvent handler sitting near the top of the tree, called thousands of times per tick. That is the actionable finding: not "the server is slow" but "this listener runs on every movement packet." Reducing how often it does heavy work — or moving that work off the main thread — is the fix.

Three useful views

Practical reading tips

• Separate your own time from waiting time. A method that blocks on I/O is not the same as one burning CPU; the fix differs.
• Watch call counts, not just percentages. A cheap method called 200,000 times per tick is a real problem.
• Check whether the spike is event-driven. If lag correlates with player joins, chunk loads or mob spawns, profile during exactly that moment rather than averaging over ten minutes.
• Compare two profiles. One at low player count and one at high player count shows what scales badly, which is usually the true culprit.

When the profile is not enough

If the hot branch is vanilla Minecraft internals rather than a plugin, the answer is usually configuration or hardware — view distance, entity limits, mob caps — not code. If it is a plugin, take the finding to that plugin's author with the profile link, since the viewer lets them inspect the same tree.

Next step: generate a profile with a short, deliberate duration during the lag, upload it, and write down the single largest branch before looking at anything else.

What are the differences between spark's profiler, memory inspection, and health reporting?

spark bundles three distinct tools under one name, and they answer different questions. The profiler tells you where time is going; memory inspection tells you what is holding memory; health reporting tells you how the server is behaving over time. They are complementary, not alternatives.

Quick comparison

Choosing between them

• Start with the profiler when the symptom is lag you can feel: block lag, mob AI stutter, slow chunk generation. It points at the offending plugin or code path.
• Switch to memory inspection when the symptom is memory pressure rather than CPU: the server climbs toward its heap limit, garbage collection pauses grow, or the process dies under load. A heap dump is heavier to handle than a profile, so treat it as a targeted investigation, not a routine check.
• Use health reporting as the baseline layer. It is the least invasive and the most useful before and after a change, because it shows trends rather than a single snapshot.

A practical workflow

A common sequence: notice lag, run the profiler to find the hot path, fix or disable the cause, then rely on health reporting to confirm the improvement holds. If the profiler looks clean but memory keeps climbing, move to memory inspection.

How the viewer fits in

The website doubles as an online viewer for spark data. You generate a profile or heap summary with the appropriate spark commands, upload it, and open the resulting link. Alternatively, produce a .sparkprofile or .sparkheap file and drag it into the viewer box. Only those two file types are accepted, so export accordingly before trying to open anything.

For setup details and the exact commands, check the documentation linked from spark, and the project's GitHub repository if you want to read the source or contribute.

Can I use spark to diagnose performance issues on a Minecraft client or proxy?

Yes. spark is designed as a performance profiler for Minecraft clients, servers, and proxies alike, so you can use it to investigate lag, stutter, and bottlenecks on a client or a proxy, not just on a server.

What it gives you in practice

• Profiler — records where time is being spent, which is the core tool for finding bottlenecks. On a client this helps with frame stutter and slow rendering or mod-related work; on a proxy it helps with plugin or network-handling overhead.
• Memory inspection — full heap dumps, a summary of what is consuming the most memory, and GC activity monitoring. Useful when the symptom is rising memory use or frequent garbage collection rather than raw CPU cost.
• Health reporting — tracks key metrics over time, so you can see whether a change actually improved things instead of guessing.
• Viewer — the site doubles as an online viewer for spark data: run the appropriate spark commands, then open the link it produces, or export a .sparkprofile or .sparkheap file and drag it into the viewer.

A concrete workflow Suppose a player reports periodic freezes on a modded client. Record a profile during the freeze, open it in the viewer, and look for the heaviest call paths; then disable or update the mods implicated and re-profile to confirm the improvement. For a proxy, the same loop applies to plugin or connection-handling code.

Decision criterion Choose spark when you need evidence about where time or memory goes, rather than a single aggregate number. If your problem is a one-off crash rather than a slowdown, a profiler is the wrong instrument — you want logs or a crash report instead.

Next step Read the official documentation and usage guides before your first capture, since the right command differs between client, server, and proxy. Downloads and docs are linked from spark, and source and discussion are available via GitHub and Discord.

How do I view a .sparkprofile or .sparkheap file with spark's online viewer?

Open spark's online viewer and drag your .sparkprofile or .sparkheap file onto the drop area on the page, or click that area to browse for the file. The viewer accepts only those two extensions, so a renamed or zipped file will not load.

You have two routes to get a file into the viewer:

• Direct upload from the game or server: Run the appropriate spark command to generate a profile or heap summary, then click the link spark prints after the data is uploaded. That link opens the viewer with your data already loaded.
• Local file: Generate or export a .sparkprofile or .sparkheap file, then drag it into the box on the viewer page or click to select it.

Which file to open

Practical notes

The viewer runs in your browser and is built with React; the source is open on GitHub. Large profiles can take a moment to parse, so give the tab time before assuming it failed.

A useful next step: if you are chasing lag on a server, capture a profile during the slowdown rather than after it, since a quiet period produces a much less informative sample. For memory issues, a heap summary taken when usage is near its peak is more revealing than one taken after a restart.