// Helper function to validate IPv6 address format
function isValidIPv6(ipv6) {
// This regex allows for '::' compression and standard hex segments.
// It's not exhaustive for all edge cases (e.g., embedded IPv4), but good for typical use.
var ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^((?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*)?)::((?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*)?)$/i;
return ipv6Regex.test(ipv6);
}
// Function to expand an IPv6 address (handle '::')
function expandIPv6(ipv6) {
var parts = ipv6.split('::');
if (parts.length === 1) {
// No '::', just pad segments to 4 chars
return parts[0].split(':').map(function(s) { return s.padStart(4, '0'); }).join(':');
}
var start = parts[0].split(':').filter(function(s) { return s !== "; });
var end = parts[1].split(':').filter(function(s) { return s !== "; });
var middle = [];
while (start.length + end.length + middle.length < 8) {
middle.push('0000');
}
return start.concat(middle).concat(end).map(function(s) { return s.padStart(4, '0'); }).join(':');
}
// Function to convert an expanded IPv6 address string to a BigInt
function ipv6ToBigInt(ipv6Expanded) {
var segments = ipv6Expanded.split(':');
var bigInt = 0n;
for (var i = 0; i < segments.length; i++) {
bigInt = (bigInt << 16n) | BigInt(parseInt(segments[i], 16));
}
return bigInt;
}
// Function to convert a BigInt to an expanded IPv6 address string
function bigIntToIPv6(bigInt) {
var segments = [];
for (var i = 0; i > BigInt(16 * (7 – i))) & 0xFFFFn;
segments.push(segment.toString(16).padStart(4, '0'));
}
return segments.join(':');
}
// Function to compress an expanded IPv6 address string (for display)
function compressIPv6(ipv6Expanded) {
var segments = ipv6Expanded.split(':');
var bestStart = -1;
var bestLen = 0;
var currentStart = -1;
var currentLen = 0;
for (var i = 0; i bestLen) {
bestStart = currentStart;
bestLen = currentLen;
}
currentStart = -1;
currentLen = 0;
}
}
if (currentLen > bestLen) {
bestStart = currentStart;
bestLen = currentLen;
}
if (bestLen > 1) { // Only compress if more than one '0000'
var compressed = [];
for (var i = 0; i < segments.length; i++) {
if (i === bestStart) {
compressed.push(''); // Placeholder for ::
i += bestLen – 1;
} else {
compressed.push(segments[i].replace(/^0+/, '') || '0'); // Remove leading zeros, but keep '0' for '0000'
}
}
return compressed.join(':').replace(':::', '::'); // Fix potential ':::'
} else {
return segments.map(function(s) { return s.replace(/^0+/, '') || '0'; }).join(':');
}
}
function calculateIPv6Subnet() {
var ipv6AddressInput = document.getElementById('ipv6AddressInput').value.trim();
var prefixLengthInput = document.getElementById('prefixLengthInput').value.trim();
var errorMessageDiv = document.getElementById('errorMessage');
var resultSection = document.getElementById('resultSection');
errorMessageDiv.textContent = '';
resultSection.style.display = 'none';
// Input validation
if (!ipv6AddressInput) {
errorMessageDiv.textContent = 'Please enter an IPv6 Address.';
return;
}
if (!isValidIPv6(ipv6AddressInput)) {
errorMessageDiv.textContent = 'Invalid IPv6 Address format. Please use standard IPv6 notation (e.g., 2001:db8::1).';
return;
}
var prefixLength = parseInt(prefixLengthInput, 10);
if (isNaN(prefixLength) || prefixLength 128) {
errorMessageDiv.textContent = 'Prefix Length must be a number between 0 and 128.';
return;
}
try {
var expandedIPv6 = expandIPv6(ipv6AddressInput);
var ipv6BigInt = ipv6ToBigInt(expandedIPv6);
var hostBits = 128 – prefixLength;
// Network Address
var networkMask = ~((1n < 0)
var firstUsableHostBigInt = networkAddressBigInt;
if (hostBits > 0) {
firstUsableHostBigInt = networkAddressBigInt + 1n;
}
var firstUsableHost = compressIPv6(bigIntToIPv6(firstUsableHostBigInt));
// Last Address in Subnet (Broadcast equivalent)
var lastAddressBigInt = networkAddressBigInt | ((1n < 0)
var lastUsableHostBigInt = lastAddressBigInt;
if (hostBits > 0) {
lastUsableHostBigInt = lastAddressBigInt – 1n;
}
var lastUsableHost = compressIPv6(bigIntToIPv6(lastUsableHostBigInt));
// Special handling for /128 and /127
if (hostBits === 0) { // /128
firstUsableHost = "N/A (Single Address)";
lastUsableHost = "N/A (Single Address)";
} else if (hostBits === 1) { // /127
// For /127, there are 2 addresses. The network address is the first, the last address is the second.
// No "usable host range" in the traditional sense for point-to-point links.
firstUsableHost = networkAddress; // The network address itself is the first "usable" for a point-to-point
lastUsableHost = broadcastAddress; // The last address is the second "usable" for a point-to-point
}
// Next Subnet Address
var subnetSize = 1n << BigInt(hostBits);
var nextSubnetAddressBigInt = networkAddressBigInt + subnetSize;
var nextSubnetAddress = compressIPv6(bigIntToIPv6(nextSubnetAddressBigInt));
// Total Addresses
var totalAddresses = subnetSize.toString(); // BigInt to string
// Display results
document.getElementById('networkAddress').textContent = networkAddress + '/' + prefixLength;
document.getElementById('firstUsableHost').textContent = firstUsableHost;
document.getElementById('lastUsableHost').textContent = lastUsableHost;
document.getElementById('broadcastAddress').textContent = broadcastAddress;
document.getElementById('nextSubnetAddress').textContent = nextSubnetAddress + '/' + prefixLength;
document.getElementById('totalAddresses').textContent = totalAddresses;
document.getElementById('hostBitsCount').textContent = hostBits;
resultSection.style.display = 'block';
} catch (e) {
errorMessageDiv.textContent = 'An error occurred during calculation. Please check your input. Error: ' + e.message;
console.error(e);
}
}
Understanding IPv6 Subnetting
IPv6 (Internet Protocol version 6) is the latest version of the Internet Protocol, designed to address the limitations of IPv4, primarily the exhaustion of available IP addresses. IPv6 uses 128-bit addresses, providing an astronomically larger address space compared to IPv4's 32-bit addresses.
IPv6 Address Structure
An IPv6 address is typically represented as eight groups of four hexadecimal digits, separated by colons (e.g., 2001:0db8:85a3:0000:0000:8a2e:0370:7334). For brevity, leading zeros in a group can be omitted, and a contiguous sequence of zero-value groups can be replaced by a double colon (::), but only once per address.
Network Prefix: The initial part of the address that identifies the network or subnet.
Interface Identifier: The latter part of the address that identifies a specific host or interface within that subnet.
The Role of the Prefix Length (CIDR)
Similar to IPv4, IPv6 uses Classless Inter-Domain Routing (CIDR) notation to define the network and host portions of an address. The prefix length, indicated by a slash followed by a number (e.g., /64), specifies how many bits from the left are part of the network prefix. The remaining bits are for the interface identifier.
A /64 prefix is the most common subnet size for general-purpose links, providing 64 bits for the network and 64 bits for hosts. This allows for 264 unique host addresses, an incredibly vast number.
Other common prefix lengths include /48 (often assigned to organizations for subnetting), /56, and /127 (for point-to-point links).
Key Differences from IPv4 Subnetting
Address Space: IPv6 offers 2128 addresses, compared to IPv4's 232. This eliminates the need for Network Address Translation (NAT) in most scenarios.
No Broadcast Address: IPv6 does not use a traditional broadcast address. Instead, it relies on multicast for sending traffic to multiple destinations. The "last address" in an IPv6 subnet is simply the highest possible address in that range, not a dedicated broadcast address.
Subnet Size: While IPv4 subnets vary greatly, /64 is the recommended and most common subnet size for IPv6, simplifying auto-configuration (SLAAC).
Loopback Address:::1 (equivalent to 127.0.0.1 in IPv4).
Unspecified Address::: (equivalent to 0.0.0.0 in IPv4).
How the Calculator Works
This IPv6 Subnet Calculator helps you understand the breakdown of an IPv6 address based on its prefix length. You provide an IPv6 address and its corresponding prefix length, and the calculator will determine:
Network Address: The first address in the subnet, representing the network itself.
First Usable Host: The first address available for assignment to a device within the subnet (typically Network Address + 1). For /128 subnets, this is N/A as it's a single address. For /127, both addresses are considered usable for point-to-point links.
Last Usable Host: The last address available for assignment to a device within the subnet (typically Last Address – 1). Similar to the first usable host, special considerations apply for /128 and /127.
Broadcast Address (Last Address in Subnet): The highest possible address within the subnet range.
Next Subnet Address: The starting address of the subsequent subnet, useful for planning.
Total Addresses in Subnet: The total number of unique addresses within the defined subnet.
Number of Host Bits: The number of bits dedicated to identifying hosts within the subnet.
Example Usage:
Let's say you have an IPv6 address 2001:0db8:abcd:0012:: with a prefix length of /64.
Input IPv6 Address:2001:0db8:abcd:0012::
Input Prefix Length:64
The calculator would then output:
Network Address:2001:db8:abcd:12::/64
First Usable Host:2001:db8:abcd:12::1
Last Usable Host:2001:db8:abcd:12:ffff:ffff:ffff:fffe
Broadcast Address (Last Address in Subnet):2001:db8:abcd:12:ffff:ffff:ffff:ffff
Next Subnet Address:2001:db8:abcd:13::/64
Total Addresses in Subnet: 18,446,744,073,709,551,616 (264)
Number of Host Bits: 64
This tool is invaluable for network administrators and engineers working with IPv6 deployments, helping to accurately plan and manage address allocations.