Double slit calculator
Get the gap between bright fringes in Young’s experiment: slits 0.5 mm apart, 600 nm light and a screen 2 m away give fringes 2.4 mm apart. Enter all three lengths in one unit and the answer comes back in it. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Slit separation d
- 0.00025
- Wavelength
- 0.0000005
- Screen distance
- 1
- Fringe spacing
- 0.002
- Precision
- 10
This double slit calculator takes a slit separation, a monochromatic wavelength, and a screen distance and returns the fringe spacing of Young's two-slit interference pattern under the usual small-angle approximation. The identity is fully deterministic: fringe spacing delta y equals wavelength times screen distance divided by slit separation, written Δy equals λ L over d. Classic checks include d equals two point five times ten to the minus four metres, λ equals five hundred nanometres, and L equals one metre, which yields a two-millimetre fringe spacing, and a wider geometry with d equals five tenths of a millimetre, λ equals six hundred nanometres, and L equals two metres, which yields two point four millimetres. The engine uses only finite arithmetic with no network calls, no sampling, and no date-dependent shortcuts.
Where double-slit fringe checks fit in study, labs, and software
Students meet Young's formula when a lab measures fringe spacing with a laser and a pair of slits, when a homework set asks for Δy given d, λ, and L, or when a contest problem wants the wavelength from a measured fringe period without building an optical bench. Teachers can pre-generate answer keys for modest SI lengths without trusting opaque calculator apps that silently convert units or drop powers of ten on nanometres.
Developers call the same contract from scripts to seed deterministic test vectors for wave-optics widgets, to normalize user-entered d, λ, and L before a classroom demo, or to satisfy programming-challenge statements that demand fringe spacing rather than a hand-waved sketch. Contest practice often needs a fast, offline source of Δy so solutions can be checked without graphing calculators under time pressure. Product and education tools use the solve when a learner types slit separation, wavelength, and screen distance and the UI must show the interference period on the screen.
What you can do with it
Homework and lab checks
Compute fringe spacing Δy from textbook d, λ, and L; verify millimetre-scale patterns before sketching bright and dark fringes.
Tutoring and optics widgets
Normalize user-entered slit separation, wavelength, and screen distance for interactive Young’s experiment demos.
FAQ
What does the double slit calculator cost?
It is free in your browser on this page.
How is fringe spacing defined?
Under the small-angle Young approximation, fringe spacing is Δy = λL/d, the distance between adjacent bright (or dark) fringes on the screen.
Do I need to convert nanometres myself?
Yes. Enter wavelength in the same length unit as slit separation and screen distance; the engine does not convert units.
Why are results rounded to a precision?
Default precision is 10 decimal places; you can set precision from 0 to 15.
What fringe spacing do slits 0.00025 m apart give with 500 nm light and a 1 m screen?
The bright fringes are 0.002 m apart, which is 2 mm. Write the wavelength in metres as well, so all three lengths share one unit and the spacing comes back in metres.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/optics/double-slit \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"slit_separation":0.00025,"wavelength":5e-7,"screen_distance":1}'const res = await fetch("https://api.kit.forhosting.com/optics/double-slit", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"slit_separation": 0.00025,
"wavelength": 5e-7,
"screen_distance": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/optics/double-slit",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"slit_separation": 0.00025,
"wavelength": 5e-7,
"screen_distance": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/optics/double-slit", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"slit_separation":0.00025,"wavelength":5e-7,"screen_distance":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"slit_separation":0.00025,"wavelength":5e-7,"screen_distance":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/optics/double-slit", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"slit_separation": 0.00025,
"wavelength": 5e-7,
"screen_distance": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "optics.double_slit",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_abs_length | 1000000000000000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
What Young's fringe spacing means and what the response contains
In Young's double-slit experiment, coherent light from two narrow slits of separation d interferes on a screen a distance L away, producing alternating bright and dark fringes. Under the small-angle approximation used in introductory wave optics, the path difference between the two slits grows linearly with angle, so the spacing between adjacent bright fringes equals the spacing between adjacent dark fringes and is given by the closed form Δy equals λ L over d. That single number is the vertical (or horizontal) period of the interference pattern measured on the screen in the same length unit you used for d, λ, and L. This calculator returns the normalized slit_separation, wavelength, and screen_distance you supplied, the computed fringe_spacing rounded to the requested precision, the precision used, a short formula string, and the method tag double_slit. There is no approximate ray-trace path and no random sampling of intensities: the engine either builds exact floating-point Δy inside the supported length range or rejects the input with invalid_input. Rejected cases include missing d, λ, or L, non-finite values, magnitudes above the documented ceiling, and any slit separation that is zero or numerically zero, because division by d is undefined and a single slit is not a double-slit geometry.
How d, λ, and L are read and how Δy stays reproducible
Optional leading plus signs and scientific notation on length strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong fringe period. Wavelength and screen distance may be positive or negative under pure arithmetic, but textbook SI usage keeps all three positive and consistent in metres or millimetres; the engine does not convert nanometres for you, so enter λ in the same unit as d and L. The preferred fields are slit_separation for d, wavelength for λ, and screen_distance for L, but aliases d, separation, and slitSeparation for the slit gap, lambda, the Greek letter λ, and wl for the wavelength, and L, D, distance, and screenDistance for the screen range, are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Zero for slit separation is never valid: if absolute d is at or below a tiny epsilon, the request fails with invalid_input because fringe spacing is undefined when the two apertures coincide. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric fields, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the double-slit formula yourself.
Where double-slit fringe checks fit in study, labs, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with other math and science endpoints when you are building a small lab of free, deterministic helpers for geometry, algebra, and introductory physics.
Integration use cases
Deterministic test fixtures
Generate reproducible fringe_spacing values for unit tests, property checks, and CI assertions in wave-optics code.
Technical questions
What happens if slit separation is zero?
The input is rejected with invalid_input. d = 0 makes Δy = λL/d undefined (division by zero).