Luarmor's second stage: what v4_init_ocmid.lua does
The file the loader downloads is 327 bytes in our copy: two comments, a Kick call and a loop. It is the branch for an unrecognised client.
v4_init_ocmid.lua is the file the loader downloads after its cache
check. It is not the protected script. In our request on 19 Oct 2026 it was 327
bytes: two comment lines, a Kick call and a loop that never ends.
That is the branch Luarmor serves when it does not recognise the client asking.
This file is the second link in a chain that starts with a small stub, and the licence service behind it uses the link to decide what a given client receives.
What the loader asks for
The last line of the stub contains the request:
a = game:HttpGet("https://cdn.luarmor.net/v4_init_ocmid.lua"..(_ca920af6193 or ""))
The URL is on a different host from the loader (cdn.luarmor.net
against api.luarmor.net), so auditing one host says nothing about
the other. The concatenation also appends _ca920af6193, a global the
stub never defines; when it is nil, the expression collapses to the
empty string and the URL is used as written.
That undefined global is a hook for a cache buster. If something earlier in the session had set it to a query string, the request would carry that value. In our run nothing set it, so the request went out clean.
The response we got
| Field | Value |
|---|---|
| URL | https://cdn.luarmor.net/v4_init_ocmid.lua |
| Requested | 19 Oct 2026, 10:38:33 UTC |
| Size | 327 bytes |
| SHA-256 | a1c78c98... |
content-type |
text/plain |
| Server | Cloudflare |
The request came from a plain HTTP client, ten seconds after the loader download. No key, executor or project id was sent, so the response is what any anonymous request receives.
What the file says
The whole file is three statements:
-- If you are seeing this, it means your executor is not supported by Luarmor.
-- Create a ticket in gg/luarmor and provide details.
game:GetService("Players").LocalPlayer:Kick("Your executor is not supported by Luarmor. Create a ticket in .gg/luarmor and provide us the details so we can support it.")
while wait(1) do end;
Read in order, it names the service, points to a support channel, ends the session and keeps the thread alive. There is no licence check, key, download or game logic.
Why a plain request gets the rejection branch
The endpoint answers according to who asks. A request without an executor environment carries no fingerprint beyond a user agent, so the service cannot match it to its supported list and returns the branch that says so. The loader itself is generated per request, a fact measured in the two-download comparison on the first stage.
The same URL can therefore serve different content to different clients, and probably does. The 327-byte file is the refusal path, not the normal one.
What a supported client receives
No sample of that branch exists, so what follows comes from the design of the
stub rather than from a response: the stub calls loadstring(a)(b)
and passes a short project id, so the init on that path has to accept an id and
decide which project to protect. The licence check described in Luarmor's
documentation, with key, HWID and expiry, has to happen on that path or further
down. Which clients count as supported is a separate question, covered in
which executors
work.
Luarmor does not publish the init source, and we have no copy of it. Anything that claims to show "the real init" without a supported executor and a valid key is guessing, and the guess is easy to spot because it tends to reuse this exact rejection text.
Why the Kick and the loop
Kick closes the client session from the local player. It is a client
call, so an executor with hooks can intercept it, but that does not restore the
session. The while wait(1) do end line keeps the chunk from
returning, so whatever called it does not continue into a second step.
Together they make the rejection final for the session. The comment above them is addressed to the user, not to a developer: it says what happened and where to ask for support. That wording is why the message appears verbatim in so many help requests.
The argument that arrives
The loader runs the second stage like this:
return loadstring(a)(b)
with b set to "d049a886a1f-ocmid" in our copy. The
chunk receives that string as its vararg. The rejection file ignores it entirely,
which is consistent: it has no project to look up.
On the path the stub implies, the same argument tells the init which project is being loaded, which is how one file can serve many sellers. It would also explain why a key from one project fails against another: the id travels with the request, so the service has something to check the key against.
Why this file never stays in the cache
The stub writes whatever it downloads to
static_content_170926/init-d049a886a1f-ocmid.lua, then checks length
on the next launch. A cached file is only reused when it holds more than 2,000
characters. This one is 327.
So the rejection is written and then ignored. Every new session fetches it again and gets the same answer, so the cache cannot hide this branch from you. For where the file lands and what else can end up there, see The static_content folder.
What this tells you about the chain
The stub comes from api.luarmor.net, the init from
cdn.luarmor.net, and the protected script after that. Each layer can
change without touching the one before it, and only the first is stable enough to
read in public.
A curl request reaches the error path, because that is all an
anonymous client can get. It can still describe the stub accurately, but not the
payload.
The suffix ocmid has no documented meaning. It appears in the file
name and in the loader's cache name, and the letters stay a label until a source
defines them.
Reading it yourself
The request is repeatable, and you should date your copy.
-
Request
https://cdn.luarmor.net/v4_init_ocmid.luaand save the body. - Count the bytes and hash the file.
- Read it as text before running anything.
- Repeat the request and compare both the identity of the response and its size.
If your body is the 327-byte rejection quoted here, your client is in the same position as ours: unrecognised, no key, no project. If it differs, you are looking at another branch, and the diff is the part worth keeping.
The date belongs in any note you publish, because the endpoint is dynamic.
Where the file sits in a full run
On a supported run the init would validate the key and the device before the protected script follows. Our run stops earlier, which is why the message says "executor is not supported" rather than "key invalid". The write-then-run order is in What the loader does with the response. For the next step after this message, see the message itself.
FAQ
Is v4_init_ocmid.lua the protected script?
No. It is the init that runs before the protected script. In the copy we received it does nothing except end the session. On a recognised client it would carry the licence step and the next download, but we have no sample of that branch and Luarmor does not publish one.
Why does this file kick me from the game?
Because the service did not recognise the client that requested it. The kick message is the intended output of that branch, not a fault in your script. It usually means the executor is not on the supported list, or the request never carried an executor identity in the first place.
Why is my copy a different size from yours?
The endpoint answers per client, so sizes depend on the branch. Ours is the anonymous rejection at 327 bytes. A supported executor with a valid key would receive a different file, and we cannot state its size. Compare the branch and the byte count.
What does the ocmid suffix mean?
No source defines it. It appears in the URL, in the loader's cache file name and in the argument passed to the chunk. Treat it as a version or variant label until documentation says otherwise.
Can I run this file outside an executor?
Not usefully. It calls game:GetService("Players") and LocalPlayer, so it needs a Roblox client environment. Running it elsewhere fails before the kick. The file also has no purpose outside the chain, so there is nothing to learn from executing it that reading it does not show.
Is a 327-byte second stage harmless?
This copy only kicks and loops, and that is all it does. Size is not a safety rating, though. The same URL can return different code to a different client, so the size of your copy says which branch you got, not what the endpoint is capable of serving.
Does the second stage change between requests?
Only one dated copy exists, so stability is unproven either way. The loader is generated per request, and this endpoint depends on the client, so it can vary. Request it twice and compare the two bodies and their sizes.
How do I know which branch I received?
Read the body. A rejection contains the support message and a Kick call. A real init would need to accept the short id argument and would not end the session. The byte count is a shortcut, but the text is the evidence, and it takes less than a minute to check.