16 On Center Joist Calculator Span Tables

16 On Center Joist Calculator Span Tables

Estimate 16 in OC joist span table values from species, grade, joist depth, live load, dead load, deflection limit, and tributary width.

Span Table Inputs

16 in OC equals 1.333 ft tributary width per joist.

Design values are approximate reference inputs for comparison.
Use clear span between supports, not total board length.
Enter 16 for standard 16 on center layout.
Optional allowance for a tub, island, safe, or concentrated item.

Calculated 16 in OC Span Table Result

📊Material and Spec Comparison

16 in

Default OC spacing

1.333 ft

Tributary width

L/360

Common floor limit

40+10

Typical floor psf

📐Reference Span Tables
Joist size SPF #2 Hem-Fir #2 DFL #2 Southern Pine #2
2x6 at 16 in OC9 ft 9 in9 ft 6 in10 ft 5 in10 ft 7 in
2x8 at 16 in OC12 ft 9 in12 ft 6 in13 ft 8 in13 ft 11 in
2x10 at 16 in OC16 ft 1 in15 ft 8 in17 ft 2 in17 ft 7 in
2x12 at 16 in OC19 ft 0 in18 ft 6 in20 ft 4 in20 ft 8 in
🌲Species Design Value Table
Species and grade Fb bending E stiffness Fv shear Fc perp
SPF #2875 psi1.4 Mpsi135 psi425 psi
Hem-Fir #2850 psi1.3 Mpsi150 psi405 psi
DFL #2900 psi1.6 Mpsi180 psi625 psi
Southern Pine #21100 psi1.6 Mpsi175 psi565 psi
DFL Select Structural1500 psi1.9 Mpsi180 psi625 psi
Load and Deflection Reference
Use case Live load Dead load Deflection Notes
Bedroom or living area40 psf10 psfL/360Common residential floor
Tile bathroom40 psf15 psfL/480Stiffer finish check
Sleeping attic storage30 psf10 psfL/360Use local attic rules
Ceiling joist only20 psf5 psfL/240Not a floor rating
Balcony or assembly60 psf10 psfL/360Higher live load
📏Joist Depth Section Properties
Nominal size Actual size Section modulus Moment of inertia Typical role
2x61.5 x 5.5 in7.56 in³20.8 in⁴Short spans, ceilings
2x81.5 x 7.25 in13.14 in³47.6 in⁴Decks, small rooms
2x101.5 x 9.25 in21.39 in³98.9 in⁴Common floors
2x121.5 x 11.25 in31.64 in³178.0 in⁴Longer floor spans
Span table tip: A 16 in OC joist carries a 16 inch tributary strip. Changing spacing changes line load directly, so a 12 in layout can span farther and a 24 in layout usually spans less.
Deflection tip: Strength may pass while stiffness controls. For tile, stone, plaster, or sensitive finishes, compare the L/480 or L/720 result before choosing a joist depth.
Always verify final joist spans with local building code span tables or a qualified design professional. Do not cut, notch, drill, or overload joists beyond approved structural limits.
' + unit + '
'; } function breakRow(label, value) { return '
' + label + '' + value + '
'; } function governingName(values) { var min = values[0].value; var name = values[0].name; var i = 0; for (i = 1; i < values.length; i = i + 1) { if (values[i].value < min) { min = values[i].value; name = values[i].name; } } return name; } function tcjCalculate() { var input = readInputs(); var wood = species[input.speciesKey]; var size = sizes[input.sizeKey]; var width = size.b; var depth = size.d; var sectionModulus = width * depth * depth / 6; var inertia = width * Math.pow(depth, 3) / 12; var area = width * depth; var tribFt = input.spacing / 12; var livePlf = input.live * tribFt; var deadPlf = input.dead * tribFt; var totalPlf = livePlf + deadPlf; var fbAdj = wood.fb * input.repetitive * input.wet * input.duration; var fvAdj = wood.fv * input.wet * input.duration; var fcAdj = wood.fc * input.wet; var requestedSpan = input.span; var momentFtLb = totalPlf * requestedSpan * requestedSpan / 8 + input.point * requestedSpan / 4; var bendingStress = momentFtLb * 12 / sectionModulus; var liveDeflection = uniformDeflection(livePlf, requestedSpan, wood.e, inertia); var totalDeflection = uniformDeflection(totalPlf, requestedSpan, wood.e, inertia) + pointDeflection(input.point, requestedSpan, wood.e, inertia); var livePointDeflection = pointDeflection(input.point, requestedSpan, wood.e, inertia); var allowableDeflection = requestedSpan * 12 / input.deflection; var reaction = totalPlf * requestedSpan / 2 + input.point / 2; var shearStress = 1.5 * reaction / area; var bearingStress = reaction / (width * input.bearing); var bendingSpan = solveUniformPointSpan(fbAdj, sectionModulus, totalPlf, input.point); var deflectionSpan = solveDeflectionSpan(wood.e, inertia, livePlf, input.point, input.deflection); var shearSpan = 0; var bearingSpan = 0; var governingSpan = 0; var utilization = 0; var liveLimitFromBending = 0; var liveLimitFromDeflection = 0; var liveLimit = 0; var status = ''; var govern = ''; var html = ''; if (totalPlf <= 0) { totalPlf = 0.1; } shearSpan = ((fvAdj * area / 1.5) - input.point / 2) * 2 / totalPlf; bearingSpan = ((fcAdj * width * input.bearing) - input.point / 2) * 2 / totalPlf; shearSpan = clamp(shearSpan, 0, 40); bearingSpan = clamp(bearingSpan, 0, 40); governingSpan = Math.min(bendingSpan, deflectionSpan, shearSpan, bearingSpan); govern = governingName([ { name: 'bending stress', value: bendingSpan }, { name: 'live-load deflection', value: deflectionSpan }, { name: 'joist shear', value: shearSpan }, { name: 'end bearing', value: bearingSpan } ]); utilization = requestedSpan / governingSpan * 100; if (utilization <= 85) { status = 'Pass margin'; } else if (utilization <= 100) { status = 'Near limit'; } else { status = 'Over span'; } liveLimitFromBending = ((fbAdj * sectionModulus / 12 - input.point * requestedSpan / 4) * 8 / (requestedSpan * requestedSpan) - deadPlf) / tribFt; liveLimitFromDeflection = ((allowableDeflection - livePointDeflection) * 384 * wood.e * inertia / (5 * Math.pow(requestedSpan * 12, 4)) * 12) / tribFt; liveLimit = Math.min(liveLimitFromBending, liveLimitFromDeflection); liveLimit = Math.max(0, liveLimit); html = html + resultCard('Governing Span', spanLabel(governingSpan), 'controls by ' + govern); html = html + resultCard('Requested Span Use', round(utilization, 0) + '%', status); html = html + resultCard('Live Deflection', deflectionLabel(liveDeflection + livePointDeflection), 'limit ' + deflectionLabel(allowableDeflection)); html = html + resultCard('Line Load Per Joist', lineLoadLabel(totalPlf), 'live ' + lineLoadLabel(livePlf) + ' + dead ' + lineLoadLabel(deadPlf)); html = html + resultCard('Bending Stress', round(bendingStress, 0) + ' psi', 'allowable ' + round(fbAdj, 0) + ' psi'); html = html + resultCard('Allowable Live Load', loadAreaLabel(liveLimit), 'at requested span'); html = html + '
'; html = html + breakRow('Input span and spacing', lengthLabel(requestedSpan) + ' span at ' + bearingLabel(input.spacing) + ' OC'); html = html + breakRow('Tributary width', round(tribFt, 3) + ' ft per joist'); html = html + breakRow('Species, grade, and size', wood.name + ', ' + input.sizeKey + ' actual ' + width + ' x ' + depth + ' in'); html = html + breakRow('Section properties', 'S = ' + round(sectionModulus, 2) + ' in³, I = ' + round(inertia, 1) + ' in⁴'); html = html + breakRow('Adjusted values', 'Fb ' + round(fbAdj, 0) + ' psi, Fv ' + round(fvAdj, 0) + ' psi, Fc perp ' + round(fcAdj, 0) + ' psi'); html = html + breakRow('Bending span check', spanLabel(bendingSpan)); html = html + breakRow('Deflection span check', spanLabel(deflectionSpan) + ' at L/' + input.deflection); html = html + breakRow('Shear and bearing spans', spanLabel(shearSpan) + ' shear, ' + spanLabel(bearingSpan) + ' bearing'); html = html + breakRow('End reaction and bearing stress', round(reaction, 0) + ' lb reaction, ' + round(bearingStress, 0) + ' psi bearing'); html = html + breakRow('Total-load deflection', deflectionLabel(totalDeflection) + ' under live + dead + point load'); html = html + '
'; byId('tcjResultGrid').innerHTML = html; byId('tcjResults').className = 'tcj-results active'; } function setField(id, value) { byId(id).value = value; } function tcjApplyPreset(name) { var p = presets[name]; if (!p) { return; } setField('tcjSpecies', p.species); setField('tcjSize', p.size); setField('tcjDeflection', p.deflection); setField('tcjRepetitive', p.repetitive); setField('tcjWet', p.wet); setField('tcjDuration', p.duration); if (unitSystem === 'metric') { setField('tcjSpan', round(p.span * 0.3048, 2)); setField('tcjSpacing', round(p.spacing * 25.4, 0)); setField('tcjLive', round(p.live * 0.0478803, 2)); setField('tcjDead', round(p.dead * 0.0478803, 2)); setField('tcjBearing', round(p.bearing * 25.4, 0)); setField('tcjPointLoad', round(p.point * 4.44822, 0)); } else { setField('tcjSpan', p.span); setField('tcjSpacing', p.spacing); setField('tcjLive', p.live); setField('tcjDead', p.dead); setField('tcjBearing', p.bearing); setField('tcjPointLoad', p.point); } tcjCalculate(); } function tcjSetUnits(system) { var oldSystem = unitSystem; var span = num('tcjSpan', 14); var spacing = num('tcjSpacing', 16); var live = num('tcjLive', 40); var dead = num('tcjDead', 10); var bearing = num('tcjBearing', 1.5); var point = num('tcjPointLoad', 0); if (system === oldSystem) { return; } if (system === 'metric') { setField('tcjSpan', round(span * 0.3048, 2)); setField('tcjSpacing', round(spacing * 25.4, 0)); setField('tcjLive', round(live * 0.0478803, 2)); setField('tcjDead', round(dead * 0.0478803, 2)); setField('tcjBearing', round(bearing * 25.4, 0)); setField('tcjPointLoad', round(point * 4.44822, 0)); byId('tcjSpanUnit').innerHTML = '(m)'; byId('tcjSpacingUnit').innerHTML = '(mm OC)'; byId('tcjLoadUnitA').innerHTML = '(kPa)'; byId('tcjLoadUnitB').innerHTML = '(kPa)'; byId('tcjBearingUnit').innerHTML = '(mm)'; byId('tcjPointUnit').innerHTML = '(N)'; } else { setField('tcjSpan', round(span / 0.3048, 2)); setField('tcjSpacing', round(spacing / 25.4, 1)); setField('tcjLive', round(live / 0.0478803, 1)); setField('tcjDead', round(dead / 0.0478803, 1)); setField('tcjBearing', round(bearing / 25.4, 2)); setField('tcjPointLoad', round(point / 4.44822, 0)); byId('tcjSpanUnit').innerHTML = '(ft)'; byId('tcjSpacingUnit').innerHTML = '(in OC)'; byId('tcjLoadUnitA').innerHTML = '(psf)'; byId('tcjLoadUnitB').innerHTML = '(psf)'; byId('tcjBearingUnit').innerHTML = '(in)'; byId('tcjPointUnit').innerHTML = '(lb)'; } unitSystem = system; byId('tcjImperialBtn').className = system === 'imperial' ? 'tcj-unit-btn active' : 'tcj-unit-btn'; byId('tcjMetricBtn').className = system === 'metric' ? 'tcj-unit-btn active' : 'tcj-unit-btn'; tcjCalculate(); } function tcjPrint() { window.print(); } window.tcjCalculate = tcjCalculate; window.tcjApplyPreset = tcjApplyPreset; window.tcjSetUnits = tcjSetUnits; window.tcjPrint = tcjPrint; tcjCalculate(); })();

Here’s the deal: You’re standing in an empty room, holding a pile of lumber in one hand and a tape measure in the other, wondering if these joists is really going to support floor. In this moment, intuition is often useless; physics never consults gut feelings. Enter span tables, which take complicated engineering ideas and convert them into a basic measurement (distance) so that you don’t have to guess whether your floor might sag by next winter. This website’s span table calculator uses deflection, depth, load, species and grade checks to transform that uncertainty into a clear yes/no answer regarding how well 16-inch on-center joist span will perform.

You need to know: Wood’s not all the same. Even two pieces that appear similar on hardware store shelf will behave differently, Southern pine won’t act like Spruce-Pine-Fir. That’s where the reference table on the page come in. It clearly shows how both grade and species affects the maximum allowable span. Because the modulus of elasticity is different for Hem-Fir vs. Douglas Fir-Larch, for example, a piece of DF-L can span a little farther than a piece of Hem-Fir at an equal depth. Why? Because stiffer wood resist bending better, so you can stretch further across a wider gap before you exceeds the deflection limit. It may seem like a small detail, but it makes a big difference in how complicated (and thus costly) your framing lay-out needs to be.

Why Span Tables Are Important for Strong Floors

The same principles apply when calculating beam size. When using dimension lumber, width is less important than depth. That 2×10 will be dramatically stronger than a 2×8 because it contains more wood… Yes, but also because that extra depth shifts the material away from the neutral axis (a geometric advantage). As it gets taller it become exponentially stronger. If you’re thinking about creating an open floor plan or a large great room where there would be a long span between two adult-sized sofa, upgrading to a 2×12 may allow you to avoid installing secondary support beams down the middle of the area. Less obstructions under foot = more freedom with how you can decorate inside.

Many DIYers gets confused about the terms “dead load” and “live load,” but it’s simple if you just define the difference. Dead load refers to whatever the floor will carry all the time: the joists themselves, plus any drywall on the ceiling underneath, and the weight of the subfloor and the finish flooring. That never changes. What does change is live load: a bathtub full of water, someone walking across it, some furnitures moved around, a piano being played. For normal residential codes, live loads are frequently assumed to be 40 pounds per square foot in areas where people live. If you’re going to store big appliances or a library-full of books, that figure increase. Plug those figures into the tool, which does the math for you, ensuring the joist doesn’t bend or shear and fail under the combined stress.

Real comfort comes from deflection limits. Sure, the floor may be strong enough not to break when you walk on it, but if it’s bouncing like a trampoline… it’s still a bad floor. So there are codes: they say things like L/360 (which is what normal flooring requires) and L/480 (which is what tile or stone installs require). The reason is because tile is brittle. When the joist move too much, then the tile cracks. You can save some money by having really shallow joists that barely meet code strength requirements… and you’ll have a bouncy floor which unsets your guests and ruins your luxurios finishes. Oversizing for stiffness is better than undersizing for cost. You should of known that.

There’s also the issue of spacing. Typically, we build at 16 inches on center. This is the perfect balance between using as little material as possible while keeping our structures structurally sound. If we go to 24-inch centers, for example, we’ll save a bit of lumber. However, we’ll also create a much heavier load for every single joist to bear. We frequently have to beef up beams or dig deeper. Floors that want to be solid underfoot don’t usually compute when you space them out too much.

In all, constructing a home is a way of controlling these unseen forces. The bending moment, the shear stress, they’re not visible, yet when you mess up on one, you see what happens. Understand deflection limits, load types, and material stiffness, then check the span tables to make sure your floor stays flat, quiet, and safe. I’m glad I took the extra few minutes to measure twice. It’s peace of mind.

16 On Center Joist Calculator Span Tables

Author

  • Thomas Martinez

    Hi, I am Thomas Martinez, the owner of ToolCroze.com! As a passionate DIY enthusiast and a firm believer in the power of quality tools, I created this platform to share my knowledge and experiences with fellow craftsmen and handywomen alike.

Leave a Comment