Bit mask generator
Four consecutive ones starting at bit 0 make the mask 15: 0b1111 in binary and 0xf in hex. Give the width and, if needed, the lowest bit position, and get the mask in all three bases with the exact bit range it covers. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Bits
- 4
- Start
- 0
- Mask decimal
- 15
- Mask binary
- 0b1111
- Mask hex
- 0xf
- Lowest bit
- 0
A bit mask of consecutive ones is the building block of flag fields, packed protocol headers, and register windows in firmware and systems code. You need N ones in a row, sometimes left-shifted so the field starts at bit k, and you need the same value in binary for bit-level review, decimal for constants, and hexadecimal for datasheets. This bit mask generator accepts the width in bits and an optional start position for the lowest set bit, applies the classic formula of one shifted left by the width minus one, then shifted left by the start, and returns decimal, binary with a 0b prefix, and hexadecimal with a 0x prefix plus the inclusive bit range.
How consecutive one-bit masks are built
A run of consecutive one-bits is the mask you use when a multi-bit field lives inside a larger word. If the field is four bits wide and sits at the least significant end, the mask is binary 1111, decimal fifteen, hex 0xf. If that same four-bit field starts at bit two, you keep the four ones and shift them left by two, yielding binary 111100, decimal sixty, hex 0x3c.
Algebraically the unshifted run is two to the power of the width minus one, written in shift form as open parenthesis one left-shift width close parenthesis minus one; multiplying by two to the start power is the second left shift. This capability encodes exactly that identity: mask equals open parenthesis open parenthesis one left-shift bits close parenthesis minus one close parenthesis left-shift start. Bit zero is always the least significant bit, matching C, JavaScript, Rust, and almost every CPU reference manual.
Where a bit mask generator earns its keep
Firmware and driver authors define packed status and control fields every day; generating the mask once avoids off-by-one errors when the field moves in a silicon revision. Protocol designers and reverse engineers document wire formats with hex constants and need matching binary diagrams for blog posts and RFCs. Compiler and VM authors emit mask-and-shift sequences for bitfield extraction and want an oracle that matches textbook form for regression suites.
Educators teaching bitwise operators can give students width and start and compare their handwritten 0b and 0x answers against a deterministic service instead of a full CPU simulator. Keep requests small, pin the three bases in tests, and you get reproducible flag constants for SDKs, CMS snippets, and edge workers without standing up a local bit-twiddling library of your own.
What you can do with it
Packed register and flag constants
Generate decimal, 0b, and 0x masks for multi-bit register fields given width and LSB start so drivers and datasheet tables stay consistent.
Protocol and wire-format docs
Document header bitfields with matching binary diagrams and hex constants from the same consecutive-ones formula.
Teaching bitwise shifts and masks
Let students check ((1 << bits) - 1) << start against graded homework without hand-counting ones after each shift.
FAQ
How do I generate a bit mask of consecutive ones?
Send bits (width, 1–53) and optional start (LSB index, default 0).
What does the start parameter mean?
start is the bit position of the lowest set bit, counting from zero at the least significant bit. The ones occupy bits start through start + bits - 1 inclusive.
Is bit zero the least significant bit?
Yes. Bit numbering matches common CPU and language conventions: shifting left by start moves the field toward more significant bits.
How do I build a mask for a field that starts at bit 2?
Keep the field's width and set the lowest bit to 2. A four-bit field becomes binary 111100, decimal 60 and hex 0x3c: the same four ones as 1111, shifted two places to the left.
What are the limits on width and start position?
The width can be 1 to 53 bits, and width plus start position cannot exceed 53. That keeps every mask a whole number that stays exact in decimal, binary and hex, with no rounding.
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/dev/bit-mask-generate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bits":4}'const res = await fetch("https://api.kit.forhosting.com/dev/bit-mask-generate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bits": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/bit-mask-generate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bits": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/bit-mask-generate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bits":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bits":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/bit-mask-generate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"bits": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.bit_mask_generate",
"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.
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
Limits keep every result inside a safe integer so JSON clients never lose precision.
How consecutive one-bit masks are built
The response echoes bits and start, then exposes mask_decimal as a JSON number, mask_binary as a 0b-prefixed string of significant bits only, and mask_hex as a 0x-prefixed lowercase hex string without forced padding so short fields stay readable. lowest_bit and highest_bit name the inclusive range of set bits so you can document a register window without recounting ones by hand. formula restates the shift identity for display next to the constants in generated docs or unit-test comments.
Input contract, limits, and error behaviour
Successful calls always return the same pure shape: echoed bits and start, the three bases, the inclusive bit indices, and the formula string. The implementation uses BigInt shifts internally so intermediate operations never hit the signed thirty-two-bit trap of JavaScript number shifts, then converts to a safe Number for the decimal field. POST a JSON body with bits required: a finite integer from one through fifty-three describing how many consecutive ones you want. start is optional and defaults to zero; when present it must be an integer from zero through fifty-two naming the position of the lowest set bit. Because JSON numbers share the IEEE double mantissa, the product constraint start plus bits must be at most fifty-three so the mask never exceeds two to the fifty-three minus one, Number.MAX_SAFE_INTEGER. Violations, missing bits, non-integers, booleans, and empty strings fail with invalid_input naming the rule, and those failures are not billed. Example: bits equals eight and start equals zero yields mask_decimal two hundred fifty-five, mask_binary 0b11111111, mask_hex 0xff, lowest_bit zero, highest_bit seven. Example: bits equals three and start equals five yields mask_decimal two hundred twenty-four, binary 0b11100000, hex 0xe0, bits five through seven set.
Technical questions
Why is there a limit of 53 bits?
JSON numbers use IEEE doubles with a 53-bit mantissa. Keeping start + bits ≤ 53 guarantees mask_decimal is an exact safe integer with no precision loss.
What does the bit mask generator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.