How to Count Lines in a File in Lua (And the io.lines Version Trap Nobody Warns You About)

A Stack Overflow question about a large Lua text file showed this pattern:

for line in fp:lines() do
    table.insert(file, line)
end
local count = table.size(file)

That code was loading roughly 750,000 lines into a table just to count them.

For lua count lines, that is pure waste:

• memory grows with every line
• table.insert adds overhead you do not need
• the final answer is just one integer

The minimal fix is:

local count = 0
for _ in io.lines("data.txt") do
    count = count + 1
end

But there is a second trap, and it is the one most Lua articles never explain.

The real lua io.lines version difference is not "5.1 never closes and 5.4 does." The official manuals already say io.lines(filename) closes automatically at EOF in old versions too.

The real breakage is subtler:

• Lua 5.1, 5.2, and 5.3 only document the EOF-close behavior
• Lua 5.4 changed the generic for protocol so io.lines(filename) can also close the file when the loop ends because of break or an error
• embedded runtimes like LuaJIT, Redis, OpenResty, and game engines often live closer to the older compatibility story than many developers assume

This guide covers the practical lua count lines in file choices:

• lua io.lines for the shortest full-file count
• io.open plus explicit close for the safest cross-version default
• byte scanning for lua count lines large file
• lua file seek end for byte size, not line count
• embedded-runtime patterns for Redis, OpenResty, Neovim, and LÖVE

If you searched for lua count lines, the short answer is:

• standard local file, all versions: io.open + fh:lines() + explicit fh:close()
• complete EOF scan and you want brevity: for _ in io.lines(path) do ... end
• huge file and only need the number: binary chunk scan

That is the real count lines lua rule of thumb: count, do not store; close explicitly when you care about version-safe resource behavior.

Quick Method Guide

For most lua count lines in file code, io.open plus fh:lines() is the strongest default because it avoids both the storage anti-pattern and the cross-version close ambiguity.

Method 1: io.lines - Concise, but Version-Sensitive

The simplest possible version is:

local count = 0
for _ in io.lines("data.txt") do
    count = count + 1
end
print("Lines: " .. count)

Count non-empty lines:

local count = 0
for line in io.lines("data.txt") do
    if line ~= "" then
        count = count + 1
    end
end

Count non-comment configuration lines:

local count = 0
for line in io.lines("config.ini") do
    if line:match("%S") and not line:match("^%s*#") then
        count = count + 1
    end
end

This is the most compact lua io.lines form, and for a full run to EOF it is usually fine.

The real Lua 5.1 vs 5.4 trap

The common story on forums is often wrong.

Lua 5.1 already documents io.lines(filename) as opening the file and automatically closing it when the iterator detects EOF.

Lua 5.4 still does that, but the 5.4 manual adds something new: io.lines(filename) returns extra values that let the generic for loop treat the file as a closing value. The manual explicitly says this means the file is also closed if the loop ends by break or by an error.

So the real compatibility table is:

That is the version trap worth caring about in lua io.lines close file discussions.

If your code always consumes all lines to EOF, the version difference matters less.

If your code exits early, wraps the iterator in helpers, or runs in a long-lived embedded process, explicit handle ownership is still safer.

io.lines versus file:lines

This distinction matters more than many tutorials admit.

io.lines("filename"):

• opens the file for you
• returns an iterator
• closes automatically on EOF
• in Lua 5.4, also closes on break / loop error in generic for

fh:lines():

• uses a file handle you already opened
• returns an iterator
• does not close the file when the loop ends

Example:

local fh = assert(io.open("data.txt", "r"))

local count = 0
for _ in fh:lines() do
    count = count + 1
end

fh:close()
print("Lines: " .. count)

For lua count lines in file, fh:lines() is often the better long-form answer because the close boundary is explicit and stable across versions.

Do not store lines just to count them

This is the Stack Overflow anti-pattern:

local file = {}
for line in fp:lines() do
    table.insert(file, line)
end
local count = #file

This is the right version:

local count = 0
for _ in fp:lines() do
    count = count + 1
end

That is the first serious lesson of lua count lines large file: count, do not collect.

Method 2: io.open + fh:lines() - The Safe Universal Approach

For all standard Lua versions, the most dependable answer is explicit open and explicit close:

local function count_lines(filename)
    local fh, err = io.open(filename, "r")
    if not fh then
        return nil, "Cannot open '" .. filename .. "': " .. (err or "")
    end

    local count = 0
    for _ in fh:lines() do
        count = count + 1
    end

    fh:close()
    return count
end

This is the strongest baseline for lua count lines in file because:

• it works across 5.1 through 5.4
• it avoids the io.lines loop-close ambiguity
• it keeps memory flat

Count data lines:

local function count_data_lines(filename)
    local fh, err = io.open(filename, "r")
    if not fh then
        return nil, err
    end

    local count = 0
    for line in fh:lines() do
        if line:match("%S") and not line:match("^%s*#") then
            count = count + 1
        end
    end

    fh:close()
    return count
end

fh:read("*l") versus fh:read("l")

This is another real version wrinkle.

The old Lua 5.1-style manuals document formats like:

• "*l" for line
• "*a" for all
• "*n" for number

Lua 5.4 documents:

• "l"
• "L"
• "a"
• "n"

LuaJIT's extension docs explicitly say io.read() and file:read() accept formats with or without a leading *.

So if you insist on read instead of lines, version-safe code should be explicit about the runtime:

local function count_lines_read(filename)
    local fh = assert(io.open(filename, "r"))
    local count = 0

    local fmt
    if _VERSION == "Lua 5.1" or _VERSION == "Lua 5.2" then
        fmt = "*l"
    else
        fmt = "l"
    end

    while fh:read(fmt) do
        count = count + 1
    end

    fh:close()
    return count
end

For most people, fh:lines() is cleaner because it sidesteps the documented *l versus l split.

Method 3: Byte Scanning - High Performance for Large Files

If you only need the number, not the lines themselves, lua count lines large file often means byte scanning.

local function count_lines_fast(filename, buf_size)
    buf_size = buf_size or 65536

    local fh = assert(io.open(filename, "rb"))
    local count = 0
    local saw_data = false
    local last_char = "\n"

    while true do
        local chunk = fh:read(buf_size)
        if not chunk then
            break
        end

        saw_data = true
        local _, n = chunk:gsub("\n", "")
        count = count + n
        last_char = chunk:sub(-1)
    end

    fh:close()

    if saw_data and last_char ~= "\n" then
        count = count + 1
    end

    return count
end

This is the correct replacement for the 750,000-line table pattern:

• O(1) extra memory
• no table.insert
• faster for large files

Why count > 0 is the wrong final-line check

Many snippets make this mistake:

if last_char ~= "\n" and count > 0 then
    count = count + 1
end

That fails for a one-line file with no newline:

• newline count is 0
• there is still one logical line

The safe condition is whether the file had any data at all:

if saw_data and last_char ~= "\n" then
    count = count + 1
end

That handles:

• empty file -> 0
• hello -> 1
• a\nb\n -> 2
• a\nb -> 2

Similar byte-scan patterns in other runtimes

If you like this style, the same "count bytes, not strings" approach shows up in the Java line counting guide and the Bash wc -l guide.

Method 4: fh:seek("end") - File Size in Bytes, Not Lines

The lua-users wiki shows the classic length pattern:

local function file_size_bytes(filename)
    local fh = assert(io.open(filename, "rb"))
    local size = assert(fh:seek("end"))
    fh:close()
    return size
end

That answers lua file seek end, not lua count lines.

Important distinction:

• byte size can be useful for emptiness checks, progress bars, and rough sizing
• byte size is not line count unless line width is fixed and known

If you want both in one pass:

local function file_info(filename, buf_size)
    buf_size = buf_size or 65536

    local fh = assert(io.open(filename, "rb"))
    local size = assert(fh:seek("end"))
    assert(fh:seek("set", 0))

    local count = 0
    local saw_data = false
    local last_char = "\n"

    while true do
        local chunk = fh:read(buf_size)
        if not chunk then
            break
        end

        saw_data = true
        local _, n = chunk:gsub("\n", "")
        count = count + n
        last_char = chunk:sub(-1)
    end

    fh:close()

    if saw_data and last_char ~= "\n" then
        count = count + 1
    end

    return { bytes = size, lines = count }
end

This is the honest answer when somebody asks for both byte size and line count from the same Lua function.

Part 5: Embedded Environments - Redis, OpenResty, Neovim, LÖVE

Lua often runs inside somebody else's runtime, and those environments matter more than generic snippets.

Redis Lua scripting

Redis's official Lua API docs say Redis includes an embedded Lua 5.1 interpreter, and that scripting disables the filesystem, networking, and other system calls outside the supported API.

That means:

• you cannot do io.open() inside normal Redis scripts
• redis lua count lines file is really an application-layer task

So the safe answer is: count the file before the script runs, not inside the Redis VM.

OpenResty and openresty lua count lines

OpenResty documents that modern releases use LuaJIT by default. Its FAQ also explains why the ecosystem stays close to Lua 5.1 compatibility.

That means two things for openresty lua count lines:

• prefer explicit io.open and fh:close() if you do local file reads
• do not assume Lua 5.4's stronger io.lines loop-close guarantees

Example:

local function count_config_lines(filename)
    local fh, err = io.open(filename, "r")
    if not fh then
        return nil, err
    end

    local count = 0
    for _ in fh:lines() do
        count = count + 1
    end

    fh:close()
    return count
end

If you want the 5.1-style documented format explicitly:

local function count_lines_lua51(filename)
    local fh = assert(io.open(filename, "r"))
    local count = 0

    while fh:read("*l") do
        count = count + 1
    end

    fh:close()
    return count
end

Neovim plugins

Neovim's build docs say the default bundled dependency is LuaJIT, while PUC Lua is an optional build choice.

So for plugin code:

• do not assume every install behaves like standalone Lua 5.4
• explicit open / close is still the safest local-file pattern

local function count_lines_neovim(filename)
    local fh, err = io.open(filename, "r")
    if not fh then
        return nil, err
    end

    local count = 0
    for _ in fh:lines() do
        count = count + 1
    end

    fh:close()
    return count
end

If you really just want a shell count in editor tooling, the Shell wc -l guide covers the command you would be delegating to.

LÖVE

LÖVE has its own filesystem API:

local function count_lines_love(filename)
    local count = 0
    for _ in love.filesystem.lines(filename) do
        count = count + 1
    end
    return count
end

The official LÖVE docs describe love.filesystem.lines as iterating over file lines inside LÖVE's filesystem model, which is why io.open is not the right first answer there.

Part 6: A Cross-Version Compatible Line Counter

The helper below keeps the behavior boring across standalone Lua and LuaJIT-style environments.

local LineCounter = {}

function LineCounter.count(filename, opts)
    opts = opts or {}

    local skip_empty = opts.skip_empty or false
    local skip_comments = opts.skip_comments or false
    local comment_prefix = opts.comment_prefix or "#"

    local fh, err = io.open(filename, "r")
    if not fh then
        return nil, "Cannot open '" .. filename .. "': " .. (err or "unknown")
    end

    local count = 0
    for line in fh:lines() do
        if skip_empty and line:match("^%s*$") then
            -- skip
        elseif skip_comments and line:match("^%s*" .. comment_prefix) then
            -- skip
        else
            count = count + 1
        end
    end

    fh:close()
    return count
end

function LineCounter.count_fast(filename, buf_size)
    buf_size = buf_size or 65536

    local fh, err = io.open(filename, "rb")
    if not fh then
        return nil, err
    end

    local count = 0
    local saw_data = false
    local last_char = "\n"

    while true do
        local chunk = fh:read(buf_size)
        if not chunk then
            break
        end

        saw_data = true
        local _, n = chunk:gsub("\n", "")
        count = count + n
        last_char = chunk:sub(-1)
    end

    fh:close()

    if saw_data and last_char ~= "\n" then
        count = count + 1
    end

    return count
end

function LineCounter.count_batch(filenames)
    local results = {}

    for _, filename in ipairs(filenames) do
        local n, err = LineCounter.count(filename)
        if n then
            results[filename] = n
        else
            results[filename] = "ERROR: " .. (err or "unknown")
        end
    end

    return results
end

return LineCounter

Usage:

local LC = require("line_counter")

print(LC.count("data.txt"))
print(LC.count("config.ini", { skip_empty = true, skip_comments = true }))
print(LC.count_fast("huge.log"))

The point of this helper is not novelty. It is making lua count lines in file code predictable across runtimes that do not all share the same io.lines cleanup guarantees.

Benchmark: Representative Comparison

These numbers are representative rather than locally reproduced. This machine does not have lua or luajit installed, so the relative shape below is based on the official APIs and the usual overhead profile of each approach.

The important result is not the exact millisecond count. It is this:

• lua io.lines is fine for the shortest full-scan loop
• explicit io.open is better when version boundaries matter
• table.insert is the real large-file anti-pattern
• byte scanning wins when you only need the number

Quick FAQ

How do I count lines in Lua?

Use io.open, iterate with fh:lines(), increment a counter, and close the handle explicitly.

Does io.lines close the file in Lua?

Yes at EOF in the standard manuals. The important difference is that Lua 5.4 additionally documents automatic closing when the generic for loop ends via break or an error.

How do I count lines in a large file in Lua?

For lua count lines large file, use a byte scan when you only need the number, or fh:lines() when you want the simpler text-line abstraction.

How do I count lines in Lua 5.1?

Use explicit io.open plus fh:lines() or fh:read("*l"), and close the handle yourself.

How do I count lines in OpenResty Lua?

Treat it like a LuaJIT or Lua-5.1-compatible environment and prefer explicit open / close.

How do I get file size in Lua?

Use fh:seek("end"). That gives bytes, not lines.

How do I count lines without loading into a table?

Use a counter loop. Storing every line is unnecessary unless you need the content later.

Sources Checked

• Lua 5.1 reference manual, including io.lines, file:lines, and file:read("*l"): https://www.lua.org/manual/5.1/manual.html
• Lua 5.2 reference manual, showing the pre-5.4 io.lines and file:lines behavior: https://www.lua.org/manual/5.2/manual.html
• Lua 5.4 reference manual, including io.lines closing values and file:read("l"): https://www.lua.org/manual/5.4/manual.html
• LuaJIT extension docs, including compatibility notes and file:read() formats with or without *: https://luajit.org/extensions.html
• Redis Lua API docs, including the embedded Lua 5.1 interpreter and disabled filesystem/system calls: https://redis.io/docs/latest/develop/programmability/lua-api/
• OpenResty FAQ and LuaJIT docs: https://openresty.org/en/faq.html and https://openresty.org/en/luajit.html
• OpenResty Lua nginx module overview: https://openresty.org/en/lua-nginx-module.html
• Neovim build docs, including bundled LuaJIT by default and optional PUC Lua builds: https://neovim.io/doc/build/
• LÖVE filesystem docs, including love.filesystem.lines: https://www.love2d.org/wiki/love.filesystem.lines and https://www.love2d.org/wiki/love.filesystem
• lua-users wiki examples for file size with fh:seek("end"): https://lua-users.org/wiki/FileInputOutput and https://lua-users.org/wiki/IoLibraryTutorial
• Stack Overflow large-file anti-pattern and chunk-count alternatives: https://stackoverflow.com/questions/43577570/how-to-read-the-number-of-lines-in-a-large-text-file-effeciently

Related Guides and Tools

• Python line counting
• Bash wc -l guide
• Java NIO patterns
• Perl line counting
• Line Counter tool

Building a Lua plugin for Neovim, Redis, or a game engine?

Need to verify a config file or log file line count? Paste the file into the Line Counter. No table.insert. No memory bloat. Just the number.