kolo docsbeta

Limits

Every fixed size, count, timeout and configurable default of the Kolo libraries, one table per library.

On this page

Before the numbers

Deletion is best effort. It holds on peers that follow the protocol. A peer that already received an entry key can keep it, and old copies of a disk can still hold a deleted key. See Deletion.

Kolo is IPv4 only: IPv6 addresses are refused, the v4-mapped form included. Every library is experimental.

kolo-id

LimitValue
Seedexactly 32 bytes
Key fileregular file of exactly 32 bytes
Signing context1 to 255 bytes
Public key for Verify32 bytes
Small-order keys refused by Verifyall 14 encodings
Key file mode0600
New parent directory mode0700
Recovery phraseexactly 24 words of the BIP-39 English list, ASCII only; ParsePhrase reads at most 1024 bytes
Certificateat most 256 bytes, or 514 with an approver parent
Certificate offerat most 450 bytes, 192 without a parent
Revocationat most 472 bytes, 182 when the person key or the device itself signs it
Certificate file1 to 514 bytes, mode 0600
Certificate chainat most 2 certificates (person, approver, device); an approver cannot issue an approver
Certificate serialat least 1
Contexts that start with kolo-id/device-refused by Sign (ErrInvalidContext) and by VerifyDevice
Work of one VerifyDeviceat most 4 certificate signatures and 1 message signature, plus work linear in the revocation list

See kolo-id, Good to know.

kolo-codec

LimitValue
Varintat most 10 bytes, 64 bits
Bytes(max), String(max)length at most max, checked before allocating
UvarintMax(max)value at most max
Boolone byte, 0 or 1

See kolo-codec, Good to know.

kolo-log

LimitValue
Entry size, 64-bitabout 254 GiB
Entry size, 32-bitabout 512 MiB
Smallest padded entry256 bytes (entries up to 254 bytes)
Entry on diska 256-byte frame and 296 bytes of stored ciphertext for entries up to 254 bytes
Padding of larger entriesPadmé, at most about 6% extra
Memory per entryabout 64 bytes of tree hashes and 144 bytes of record, whatever the entry size
Log ID32 bytes, random
Tree hash32 bytes (BLAKE2b-256)
Proof pathat most 65 hashes
JSON inputat most 4 KiB, 8 KiB for proofs
Writable logs per (author key, log ID)1 per process (ErrLogOpen)
Logs per Storage1: New and NewReplica return ErrStorageNotEmpty for a storage that already holds an entry
AddKeysat most MaxAddKeys, 32,768 keys per call; more is ErrTooManyKeys
EntrySecret (derived keys)32 uniformly random bytes

See kolo-log, Good to know.

kolo-store

LimitValue
Store directorycreated with mode 0700, group or other access refused
Pebble file mode0600 for every file Pebble creates in the directory
PebbleOptions.MemTableSize0 (Pebble's 4 MiB) or 1 MiB to 1 GiB, ErrInvalidOptions otherwise; memory up to twice the size
Open logs per log ID1 per backend in a process (ErrLogInUse)
Logs per log ID in a store1, whatever the owner; an ID held for another owner returns kololog.ErrBadLogHeader
Memory per open log or replicaabout 250 bytes per entry, whatever the entry size
Batch of one Adoptunder 2 GiB (1 GiB on 32-bit), counted as Pebble counts a batch; ErrTooLarge from 2 GiB on. It holds the entries it adds, and Pebble a second copy
Pebble batchunder 4 GiB - 1 bytes (2 GiB - 1 on 32-bit); ErrTooLarge otherwise
Stored record, head or delete markerat most 1024 bytes
Stored entry keyexactly 32 bytes; absent on a deleted entry and on a replica entry received without its key (only an own log's live entry without its key is ErrCorrupt)
Replica catch-up headat most 1024 bytes
Replica catch-up proofat most 65 hashes
Stored entry value version3 (versions 1 and 2 refused)

See kolo-store, Good to know.

kolo-sync

LimitValue
MaxMessageSize4 MiB, length prefix checked before allocating
Entry whose padded ciphertext does not fit in one messagecannot be synced or fetched (ErrTooLarge), deleted or not, and the log does not sync past it
MaxStreams16 per connection, pull and fetch streams alike, more answered busy
ServerOptions.MaxTotalStreams256 (DefaultMaxTotalStreams) over all connections, more answered busy (ErrBusy for the client)
ServerOptions.MaxAnswerBytes256 MiB (DefaultMaxAnswerBytes), at least 2 x MaxMessageSize, over all connections; an answer counts twice its size, and one that does not fit is answered busy
Timeout60s to open a stream, for the start of each message read or write, and per wait for a request; a message of n bytes may take another n at MinRate
MinRate16 KiB/s, the slowest average speed of a message
Answer to a request for entriesabout 1 MiB; a larger entry goes alone, up to MaxMessageSize
PullOptions.InFlight1 to 8 (MaxInFlight); any other value is ErrInvalidArgument. For a peer that streams, the most requests of credit a pull keeps waiting, 8 if 0; for an older peer, the answers asked for and not stored, 3 (DefaultInFlight) if 0
Credit of a streamed pull2 MiB a request, from 2 requests up to InFlight waiting; a server holds at most 64 MiB of credit for one stream
Answers a pull holds that are not stored yet6 MiB at most; one commit stores the waiting answers up to 4 MiB
Entries one STATE answer looks atat most 32768 (MaxMessageSize / 128), then the puller asks for the rest; it reads only delete markers and keys, never a ciphertext
Head, header, record, marker or proof on the wireat most 4 KiB each
Entry key on the wire0 or 32 bytes
Fetch memorythe range asked for, at most one message more

See kolo-sync, Good to know.

kolo-kv

LimitValue
MaxKeySize32 KiB (the empty key is valid)
MaxValueSize1 MiB
Values of one keyonce a key holds 65536 values since its last delete, the next Put first deletes them
Entries one delete entry lists1 to 65536
Destroying the listed entriesone Log.Delete, one durable write
Memorythe index (each live key and the number of its entry); values are read from storage when asked for

See kolo-kv, Good to know.

kolo-braid

A zero field takes its default. A value outside its range returns ErrInvalidConfig for GroupConfig, fixed by the genesis entry, or ErrInvalidArgument for the local Limits.

LimitValue
GroupConfig.MaxMembers64, from 2 to 1024
GroupConfig.MaxSettlers7 or MaxMembers if smaller, from 1 to 64
GroupConfig.MinSettlers4 or MaxSettlers if smaller, from 1 to MaxSettlers
GroupConfig.MaxBody1 MiB, from 1 KiB to 3 MiB
GroupConfig.CheckpointEvery1024 settled positions, from 64 to 2^20
Limits.MaxTail2048 entries, from 64 to 2^20
Limits.MaxPendingBytes16 MiB, from 1 MiB to 1 GiB; one strand holds at most MaxPendingBytes / MaxMembers of it, one entry always fits
Limits.MaxForks4, from 1 to 64: the second histories of one strand a peer keeps; the entries of the next are refused and no longer fetched
Limits.PulseGap500 ms, from 10 ms to 1 min
Limits.PivotWait3 s, from 100 ms to 5 min
Limits.AnnounceGap100 ms, from 10 ms to 10 s
Limits.ConfirmWait10 s, from 1 s to 5 min
Limits.MaxEvents1024, from 16 to 2^16
View key and value32 KiB and 1 MiB
Writes of one entry16 x MaxBody, each operation costing its key and value plus 256 bytes
App tag1 to 64 bytes of UTF-8
Join request and welcome64 KiB and 1 MiB
Stream message4 MiB
Pulls at once16, one per strand
Answer to a request, unknown key60 s, then the connection is closed
Disk per entryabout 600 bytes on every peer; history is never pruned

The devices package takes devices.Options. The first three are bounds of apply, so every peer of a group must use the same values.

LimitValue
MaxCertsPerPerson1024, 1 to 2^20: the certificates of one person in a view
PersonCertReservean eighth of MaxCertsPerPerson (128), 0 to MaxCertsPerPerson, -1 for none: slots kept for certificates the person key issued
MaxRevocationsPerDevice64, 1 to 2^16: approver revocations of one device key
MaxDevicesnone by default (the group's MaxMembers seats are the only bound); an opt-in ceiling on the devices of one person that Admit lets in, ErrTooManyDevices past it
Certificate, offer, revocation514, 450 and 472 bytes, kolo-id's encodings
Join request with a proof64 KiB; a proof is under 700 bytes

See kolo-braid, Good to know.

kolo-transport

LimitValue
Network"udp4" only
MaxConns100, 1 to 10000
MaxConnsPerIP4 (or MaxConns if lower), 1 to MaxConns
MaxDialed32, 1 to 10000
MaxIncomingStreams16 of each type per connection, 1 to 1000
HandshakeTimeout10s, 1s to 60s (also the life of a Retry token)
IdleTimeout30s, 1s to 10m
Peer's idle timeout taken as at least5s
KeepAlivePeriod5s (or IdleTimeout/2 if lower), 500ms to below IdleTimeout
MaxStreamReceiveWindow256 KiB, 64 KiB to 16 MiB
MaxConnReceiveWindow512 KiB, 64 KiB to 64 MiB
MaxMemory1 GiB, 64 MiB to 64 GiB
CongestionControl"reno" (default), "cubic" or "bbr"; any other value is ErrInvalidConfig
WindowGrowthoff; with it on, Conn.AllowWindowGrowth lets the windows of a connection grow
MaxGrownStreamReceiveWindow4 MiB, MaxStreamReceiveWindow to 16 MiB (WindowGrowth only)
MaxGrownConnReceiveWindow8 MiB, MaxConnReceiveWindow to 64 MiB (WindowGrowth only)
MaxGrownMemory64 MiB, 1 MiB to 64 GiB, shared by the connections of a Listener (WindowGrowth only)
BBR samplesat most 40000 packet numbers, about 5.5 MiB per BBR connection; older samples are dropped
Accept queue32 connections
MaxPacketSize (non-QUIC datagrams)1200 bytes
Non-QUIC datagram queue32 datagrams
MaxCode2^62-1
CloseWithError messageat most 256 bytes
ExportKey output32 bytes
NEW_TOKEN token life1ns
Listener.Close on a conn that ignores deadlines1s
ListenConn datagramsat least 1280 bytes; over 1452 truncated

See kolo-transport, Good to know.

kolo-secure

LimitValue
HandshakeTimeout10s after the QUIC handshake, 1s to 60s
MaxPending64 per listener, 1 to 1000
Handshake messagebody of 1 to 256 bytes, length of at most 2 bytes
Largest real handshake message98 bytes
remote key32 bytes
Small-order encodings refused14
Other keys a key holder can proveup to 7
Exporter value32 bytes
Close code of a failed handshake1

See kolo-secure, Good to know.

kolo-dht

LimitValue
MaxRecords65536 per server, 16 to 1,000,000
MaxRecordsPerTopic512, 1 to 65536 (a sixteenth per IPv4 /24)
MaxRecordsPerIP256, 1 to 65536
MaxAnnouncements16, 1 to 256
MaxInflight160, 8 to 4096
MaxRelays64, 1 to 4096
MaxPunches16, 1 to 256 (birthday connections: 4 per /24)
MaxRequestsPerIP50/s, 1 to 10,000
MaxRequestsPerPrefix200/s per /24, MaxRequestsPerIP to 100,000
MaxRequests10,000/s, MaxRequestsPerPrefix to 1,000,000
ANNOUNCEs that cost a check (per second: per IPv4 address, per /24, total)20, 100, 1000, or the request limits above if lower
RequestTimeout1s, 100ms to 10s
Failed requests before a table entry is dropped4 in a row
PunchTimeout45s, 1s to 2m
MaxRandomPunches1, 1 to 16
MaxRandomPunchesPerTarget, MaxRandomPunchesPerRequester1, 1 to MaxRandomPunches
RandomPunchInterval20s, 1s to 10m
RandomPunchCooldown1m, 1s to 1h, doubles up to 16 times as long
MaxRandomPunchesPerMinute4, 1 to 64
MaxPunchSockets256 or half the soft RLIMIT_NOFILE, 1 to 16384
KeepAlivePeriod of punched connections5s unless IdleTimeout is 5s or less
Accept queueSecure.MaxPending, 64 by default
Datagramat most 1200 bytes
Replyat most 20 nodes and 16 records
Routing table256 buckets of 20; per /24, 2 in a bucket and 10 in all
Recordrefreshed every 15s, dropped 20 minutes after the last refresh
Lookup10 servers at once, 100 in all, 160 signature checks
Relays per Connect3
Bootstrap addresses64
Round-trip tokenaccepted for 40 to 80s
Node IDs per IPv4 address8

See kolo-dht, Good to know.

kolo-swarm

LimitValue
MaxPeers64, 1 to 1024
MaxInboundMaxPeers/2 rounded up (32), 1 to MaxPeers
MaxTopics16, 1 to 32
Topics per hello32
MaxConnecting3, 1 to 16
Relay dials at onceup to MaxConnecting, counted apart from kolo-dht Connect calls
Config.Relaysempty by default, at most 16 relays
First contact through a relayafter up to 3 x kolo-dht PunchTimeout (135s), then at most 60s per relay tried
MaxHandshakes16, 1 to 256
MaxHandshakesPerIP4 (or MaxHandshakes if lower), 1 to MaxHandshakes
Hellos at once per key2
MaxCandidates1024, 16 to 32768
MaxEvents64, 16 to 4096
HelloTimeout10s, 1s to 60s (2s per step)
LookupInterval10m plus up to a fifth at random, 1s to 1h
RetryMin1s, 100ms to 1m
RetryMax10m, RetryMin to 1h
Connection that resets the failure countlasts 15s
Dials at once per host2
HELLO, REPLYat most 1026 and 1044 bytes
BootstrapNodesempty by default, which means the built-in public entry nodes; at most 16 entries (the same cap as kolo-node)
Addresses per bootstrap name, in all8 per name, 64 in all
Resolving a bootstrap name5s per name, in parallel, within ctx
LoadNodes filea regular file of at most 64 KiB

See kolo-swarm, Good to know.

kolo-relay

LimitValue
MaxReservations64, 1 to 100000
MaxSessions16, 1 to 10000
MaxSessionsPerPeer4 (or MaxSessions if lower)
MaxSessionsPerTarget8 (or MaxSessions if lower)
ReservationLifetime1h, 1s to 24h
MaxSessionDuration1h, 1s to 24h
MaxSessionBytes1 GiB each direction, 64 KiB to 1 TiB
SessionIdleTimeout60s, 1s to 10m
ConnectTimeout15s, 1s to 60s
ControlTimeout (relay)15s, 1s to 60s
RateBytes1 MiB per second per client connection, 16 KiB to 1 GiB
RateBurst256 KiB, 16 KiB to 64 MiB
FlushInterval1ms, 100µs to 100ms
Relay listener with Secure nilMaxConns 128, MaxConnsPerIP 4, MaxDialed 1, MaxIncomingStreams 2, windows 64 KiB and 256 KiB
ControlTimeout (client)20s, 1s to 60s
MaxPending (client)16, 1 to 256
SendQueue (client)512 packets, 8 to 1024
HandshakeTimeout in Peer when zero10s
Target wait for an announced peer40s at the defaults
Control messageat most 64 bytes
Packet frameat most 1452 bytes
Copy buffer64 KiB per direction
Inner packets1280 bytes
Reservation.Close, Conn.Closeabout 2s
Server.Close per initiatorup to 1s

See kolo-relay, Good to know.

kolo-invite

LimitValue
Zero or negative Options fieldzero takes the default, negative is ErrInvalidArgument
Timeout30s
Close of an idle invite-only connectionbetween Timeout and 1.25 times Timeout
MaxData64 KiB, at most 1 GiB
MaxPending1024
MaxPendingPerSource16
PendingTTLnone; a Manual request that waited this long is withdrawn, as if its joiner had left
MaxPendingDevices4 pending link-a-device requests, all device invites together; more get ErrBusy
MaxDeviceName64 bytes, 1 to MaxData
DevicePendingTTL2 minutes; then the request is withdrawn and its code is burned
DeviceOptions.TTL5 minutes, how long a device code lasts
DeviceJoinOptions.MaxName, MaxPayload64 bytes and 4096 bytes on the new device
MaxStreams8 per connection
SourceRate60 per minute per source, bucket of 60
InviteRate600 per minute per invite, bucket of 600
MaxSources4096
MaxEvents1024
JoinOptions.MaxPayload1 MiB
CreateOptions.TTLzero never expires
CreateOptions.MaxUseszero means 1, no upper bound
CreateOptions.Payloadat most 1 GiB, empty with Manual
Payload and join dataat most 1 GiB
OPEN and CHALLENGE framesat most 64 bytes
Other framesat most max(512, Padmé(n + 256)) + 256 bytes, n is MaxData or MaxPayload
Padded plaintextat least 512 bytes, Padmé above
Answers of one sizepayload up to 508 bytes
Code92 characters, prefix koloinv0, all lower or all upper case
Fingerprint, secret, checksum16, 32 and 4 bytes
Challenge32 bytes per stream
Linger5 minutes
Announce retrybackoff from 1s to 1 minute
Invite topicsshare the swarm's MaxTopics (16, at most 32)
Ended requests remembered for Approve and Denythe last MaxPending
Invite recordabout 100 bytes plus its payload
Joiner wait at the kolo-swarm defaultsup to about 12 minutes

See kolo-invite, Good to know.

kolo-moq

A zero field takes the default, and a value outside the range is ErrInvalidConfig.

LimitValue
SetupTimeout, RequestTimeout10s each, 1s to 10m
MaxRequests, MaxSubscriptions1000 each, 1 to 1000000; more get EXCESSIVE_LOAD
MaxObjectSize (a payload received from the peer)16 MiB, 1 KiB to 1 GiB
MaxControlMessageSize65535, 8192 to 65535
MaxNamespaceFields, MaxNameLength32 fields, 4096 bytes: the draft limits, which can only be lowered
MaxBufferedGroups (one subscription, both sides)64, 1 to 1000000
MaxBufferedBytes (one subscription, both sides)32 MiB, or MaxObjectSize if larger, up to 64 GiB
MaxNamespaces (one namespace subscription)1000, 1 to 1000000
MaxFetchBytesMaxBufferedBytes, from MaxObjectSize to 64 GiB; a FETCH beyond it is refused with EXCESSIVE_LOAD, a fill is skipped and a forwarded FETCH is reset
OriginConfig.MaxTracks1000, 1 to 1000000
OriginConfig.MaxObjectSize (a payload written to the origin)16 MiB, 1 KiB to 1 GiB
TrackOptions.Priority128 (DefaultPriority), 0 to 255; lower is more urgent
TrackOptions.CacheGroups, CacheBytes16 groups, 32 MiB; 1 to 1000000 groups, 1 KiB to 64 GiB
Delivery timeoutsnone; a value below 1 ms is rounded up to 1 ms
RelayConfig.MaxTracks1000, 1 to 1000000
RelayConfig.MaxSessionTracksMaxTracks divided by 10, at least 1; more get EXCESSIVE_LOAD
RelayConfig.MaxSessionFetches16, 1 to 1000000; more get EXCESSIVE_LOAD
RelayConfig.Resume0 (off), 1s to 1h: how long a relay keeps the announcements of a publisher whose connection was lost or that called Session.Suspend
RelayConfig.MaxResumeHeld10000, 1 to 1000000: announcements held for ended sessions at once; one that does not fit is withdrawn with its session
RelayConfig.MaxPeerResumeHeldthe session's MaxRequests (1000), or MaxResumeHeld if lower, 1 to MaxResumeHeld: announcements held for one peer key
NewGroupRequestInterval1s per subscription between two RequestNewGroup calls; a sooner one is ErrNewGroupTooSoon; a track signals TrackWriter.NewGroupRequests at most once every 1s, whatever the number of subscriptions
RelayConfig.CacheGroups, CacheBytesas in TrackOptions, for each relayed track
KeyringConfig.Retain, RetainMax450 ms, up to 1 m; Retain plus 400 ms, from Retain to 2 m. How long a replaced key still opens objects
KeyringConfig.MaxSenders64, 1 to 1024; more Receive calls fail with ErrTooManySenders
KeyringConfig.MaxKeyRate64 key messages per namespace per second, 1 to 1024; more are dropped and counted
KeyringConfig.ReplayGroups, ReplayObjects64 groups and 8192 entries per Opener, 1 to 1000000
SenderConfig.MaxTracks1024, 1 to 1000000; one more track rotates the key
Plaintext sealed under one track key2^24 units of 16 KiB, then the Sender rotates
Object ID of a sealed object, namespace of a protected broadcastbelow 2^32; 1 to 31 fields, with the key track's full name within 4096 bytes
Reason phrase and PeerImplementation from a peerat most 1024 bytes, escaped; the reason is never in Error()
Cost of an object toward MaxBufferedBytes and the cacheits payload, 48 bytes per property and 64 bytes
Payload over 64 KiBread as it arrives
Request IDs checked for repeatsthe last 65536 numbers; older ones count as repeats
Stream with no progressreset after RequestTimeout
kolo-transport MaxIncomingStreams16 by default, 1 to 1000; raise it to match the subscriptions you expect

See kolo-moq, Good to know.

kolo-media

A zero field in a config takes the default.

LimitValue
CatalogLimits.MaxTracks1024
CatalogLimits.MaxNameLen4096 bytes
CatalogLimits.MaxConfigLen65508 bytes, the largest config that fits one object property
Catalog sizemust fit the origin's MaxObjectSize, 16 MiB in kolo-moq; else ErrInvalidCatalog
Media tracks of a default origin999, since the catalog track counts against the origin's MaxTracks; then ErrTooManyTracks
CatalogPriority, AudioPriority, VideoPriority28, 48, 68; a lower number is sent first
MediaGroupTimeout30s
PlayoutConfig.MinDelay100 ms
PlayoutConfig.MaxDelay400 ms, or MinDelay if larger
PlayoutConfig.MaxBehind50 ms
PlayoutConfig.MaxFrames8192 per track
PlayoutConfig.MaxBytes16 MiB per track
Held video objectsthe same two bounds again, counted separately: up to twice each, 32 MiB by default
Audio tracks in one Playout1
Reference windowthe last 2 s of arrivals, at most 8192
Frame ahead of the referencedropped when more than 2 s ahead
Wait of a protected object for its keyMaxDelay, 400 ms by default
Held objects of a protected trackthe same two bounds again, up to three times each with the group assembler and the playout, 48 MiB by default
Held catalog object of a protected watch1, until its key arrives or a newer version replaces it
Overhead of a protected audio object24 bytes, 9.6 kbit/s at 50 objects per second; under 1 percent for video
Memory of a protected remote participant with audio and videoup to 80 MiB in kolo-media, plus kolo-moq's MaxBufferedBytes for each of its subscriptions
First frame stamped far aheadits track is silent for 2 to 3 s, then plays
Keyframe requests (WatchOptions.RequestKeyframes)after 500 ms with no frame, then 1 s, 2 s, 4 s and 8 s; after five requests for silence, none until 30 frames in a row or a loss. An unanswered request is repeated after 1 s, 2 s, 4 s and 8 s, five in a row end the asking until a frame plays

See kolo-media, Good to know.

kolo-audio

A value outside a range returns ErrInvalidConfig, ErrInvalidArgument or ErrUnsupportedFormat.

LimitValue
Format.SampleRate48000 Hz by default, 8000 to 384000 Hz
Format.Channels1 by default, 1 to 254
Config.Period10 ms, at least one frame and at most Buffer
Config.Buffer120 ms, from Period to 2 s
Config.StallTimeout12 s, longer than Period
Opus sample rate8000, 12000, 16000, 24000 or 48000 Hz
Opus channels1 or 2
Opus bitrate500 to 512000 bit/s, 0 lets libopus choose
Opus complexity1 to 10, 0 keeps the libopus default, 9
Opus packet loss0 to 100 percent
Opus CBRon or off; every packet is (bitrate * frame duration + 4) / 8 bytes, at least 1
Opus frame duration2.5, 5, 10, 20, 40 or 60 ms, 20 ms by default
opus.PacketBufferSize4000 bytes
opus.MaxPacketDuration120 ms
Longest Opus packet accepted61296 bytes; a longer one is ErrInvalidPacket
DecodeLost, DecodeFECa multiple of 2.5 ms, at most 120 ms
libopus module1 MiB of memory and a 256 KiB stack, for each encoder or decoder
Resampler module512 KiB of memory
Memory of an encoder and decoder pairabout 0.8 to 0.9 MB
PulseAudioevery request, dial and write 30 s; frames up to 16 MiB; at most 32 channels; protocol versions 21 to 32
WASAPI5 retries after a reroute, 100 ms to 1600 ms, 3.1 s in all
ALSAplayback kept filled to 3 periods
RequestAccessno timeout of its own: the prompt waits for the person, the caller's ctx bounds the wait and ctx.Err() is returned when it ends

See kolo-audio, Good to know.

kolo-video

A value outside a range returns ErrInvalidConfig or ErrInvalidFrame. Timings were measured on an Apple M5 and in a Windows 11 ARM64 VM.

LimitValue
Frame width and height1 to 65536
CaptureConfig.Width, Height640 x 480 by default, at most 65536
CaptureConfig.FrameRate30 fps, from MinFrameRate (one frame per hour) to MaxFrameRate (1000)
CaptureConfig.Buffer2 frames; when full the oldest is dropped
CaptureConfig.StallTimeout2 s, negative disables
CaptureConfig.MaxPixels8,912,896
V4L2 and Media Foundation enumeration1024 entries
VP8 frame size1 to 16383
VP9 frame size1 to 65536
vpx.Config.FrameRate30 fps, from MinFrameRate to MaxFrameRate
vpx.Config.Bitrate0.07 bits per pixel per frame, about 4.4 Mbit/s at 1080p30
vpx.Config.KeyframeInterval2 s on frame timestamps, negative for keyframes on request only
vpx.DecoderConfig.MaxPixels8,912,896, checked in every frame header
vpx.DecoderConfig.MaxPacketBytes16 MiB, at most 256 MiB (ErrTooLarge), checked before the packet is copied
vpx.Decoder packet bufferat most 1 MiB kept between calls
Native engine, real time1920x1080 at 30 fps, encode and decode
Portable engine, real timeencode up to 640x480 at 30 fps, decode up to 1920x1080
Portable engine memoryat most 1 GiB for each instance
h264.Config sizeeven, 48 to 4096 on each side, at most 36864 macroblocks
h264.Config macroblocks per secondat most 983040 (1920x1080 up to 120 fps, 3840x2160 up to 30 fps)
h264.Config.Bitrate0.07 bits per pixel per frame, 1 to 240,000,000 bit/s
h264.Config.KeyframeInterval2 s on frame timestamps, negative for keyframes on request only
H.264 output levelat most 5.1 (Table A-1 of the H.264 specification)
H.264 profilesConstrained Baseline (default), Main and High; decoder profile_idc 66, 77 and 100
h264.DecoderConfig.MaxPixels9,437,184 (36864 macroblocks), at most that value
h264.DecoderConfig.MaxPacketBytes16 MiB, at most 256 MiB
NAL units in one H.264 packetat most MaxPixels / 256 + 288
H.264 decoder pictureeach side 48 to 4096 after cropping, at most 543 macroblocks per side, within the declared level
H.264 decoder levelslevel_idc 9 to 51, levels 1 to 5.1
Pictures in one H.264 packet1
Windows H.264 encode time1280x720 16.1 ms median, 1920x1080 27.0 ms median, one run of the software transforms

See kolo-video, Good to know.

kolo-node

LimitValue
-listen:7447
-config fileone JSON object of at most 64 KiB
-bootstrapcomma-separated host:port, repeatable; with -bootstrap-file and KOLO_BOOTSTRAP at most 16 distinct entries, 8 addresses per name, 64 in all
-bootstrap-filea text file of at most 64 KiB, one host:port per line, repeatable
-firstfalse; true means no entry nodes, refused with -bootstrap or -bootstrap-file
KOLO_BOOTSTRAPunset; read only when -bootstrap, -bootstrap-file and -first are all unset
Name resolution5s per name
Bootstrap30s
-stats-interval5m, 1s to 24h
-dht-max-records65536, 16 to 1,000,000
-dht-max-records-per-topic512, 1 to 65536
-dht-max-records-per-ip256, 1 to 65536
-dht-max-inflight160, 8 to 4096, at least 75 with -bootstrap
-dht-max-relays64, 1 to 4096
-dht-max-requests-per-ip50/s, 1 to 10,000
-dht-max-requests-per-prefix200/s, up to 100,000
-dht-max-requests10,000/s, up to 1,000,000
-dht-request-timeout1s, 100ms to 10s
-dht-punch-timeout45s, 1s to 2m
relay -listen, relay -identityrequired; no port is assigned to kolo-relay
relay -allow-filenone (an open relay); a text file of at most 64 KiB with at least one key
-relay- flagskolo-relay's defaults and ranges, see kolo-node
-relay-max-conns, -relay-max-conns-per-ip128, 1 to 10000; 4
Retry until joinedafter 1 minute, doubling up to 5 minutes
Bootstrap again once joinedevery 5 minutes while fewer than 20 servers
Shutdown10s, then exit 1
Refused listener16 connections, 16 pending, 1 dialed, 1 stream, 64 KiB windows
check1 to 16 addresses, -timeout 5s, 1s to 1m
check -relay, -relay-file, KOLO_RELAYSat most 16 distinct relays; a file of at most 64 KiB
Identity file, its directory0600, 0700
systemd unitMemoryMax=512M, GOMEMLIMIT=480MiB, restart after 5s
UDP buffers (net.core.rmem_max, wmem_max)7500000
UDP port7447

See kolo-node, Good to know.

kolo-pin

LimitValue
MaxBytes (all owners), -max-bytesDefaultMaxBytes, 100 GB; past it ErrDiskFull
Capability.Quota (one owner)0 for none; past it ErrQuotaExceeded
MaxOwners (owner records), -max-ownersDefaultMaxOwners, 100,000; a new owner past it is ErrOwnerLimit, owners already kept are never refused
AddTimeout, -add-timeoutnone; past it an Add is ErrBusy and what was stored is kept
-max-conns, -max-conns-per-ip100 (1 to 10000) and 4 (at most -max-conns), kolo-transport's connection limits
One entrymust fit in one kolo-sync message of 4 MiB with its record and encryption overhead; else ErrTooLarge
Log IDs in a capabilityMaxLogs, 256, or none for all of the owner's logs
Capabilityat most MaxCapabilitySize, 8353 bytes
Requestat most MaxRequestSize, 8389 bytes, one at a time per connection
Reading a request, writing an answerTimeout, 60s
Issue time in the peer's futureat most 60s
Capability timeswhole Unix seconds, up to 2^53-1
Check for expired capabilitiesevery minute
Unused open logclosed after a minute
Open logsat most 64; the least recently used are closed first
Memory of an open logabout 250 bytes per entry; worst case about 0.42 times MaxBytes for 64 open logs
Connecting to a pinning peer10s, then ErrUnreachable
DefaultCopies, MaxFallback2, 2
Retrying a failed log deleteafter 1 minute, then twice as long each time, up to 64 minutes
Data directory, identity.key0700, 0600
-listen127.0.0.1:7450
-health127.0.0.1:7451
-metrics127.0.0.1:7452

Both byte limits count stored keys and values, not disk blocks, and are checked before anything is stored. Nothing is evicted, and deletes always pass. See kolo-pin, Good to know.