AI Powered Programmer Names Generator
Pick a tone, press the button, copy what you like. Ten names a press, built for Programmer Names.
Your names
Pick a tone and press Generate names. Ten ideas land here.
A developer nickname is the handle a programmer uses instead of a legal name on GitHub, GitLab, npm and the forums where their work gets discussed. This page groups 303 developer nicknames by the method that built each one, then states the username rules the platforms themselves publish, so a candidate can be checked before it is claimed.
That second half is missing everywhere else. Every source ranking for this query, including Google’s own AI Overview, tells a developer to keep the name short and to check whether it is free, and not one of them states a single platform’s actual rule. GitHub’s own documentation caps a username at 39 characters. GitLab’s own documentation allows 2 to 255. npm’s own documentation refuses capital letters outright. Those three numbers decide whether a name can exist, and they are the reason this page is organised the way it is.
The generator asks a language model for ten names in the tone selected, caches each of its seven tones so a tone already generated returns instantly, and refreshes its canonical set on a cadence. It does not check whether a username is taken, and it cannot: availability lives inside each platform’s account registry, which no language model can read. It does enforce one rule. Every name it returns matches the character rule GitHub publishes, so nothing it produces is a string GitHub would refuse.
Table of contents
- Newly generated developer nicknames
- What is a developer nickname?
- How does this developer nickname generator work?
- Developer nickname ideas, grouped by how each one was built
- Cool developer names
- Software developer nicknames
- Funny developer nicknames
- Developer nickname ideas by programming language
- Short developer usernames
- One-word developer pseudonyms
- Developer handles for GitHub and npm
- What are the username rules on GitHub, GitLab and npm?
- What happens to your old username after you rename?
- How do you choose between developer nickname candidates?
- What do developers actually call themselves?
- Why do the top-ranked developer nickname lists not work as usernames?
- Frequently asked questions about developer nicknames
Newly generated developer nicknames
These are the 50 most recent developer nicknames this page's generator produced, newest first, with the tone each one came from. The newest was generated 2 days ago. Nothing here is checked for availability, so test a name in the platform's own field before you commit to it.
- CodeVanguardStrong
- PixelRaptorStrong
- ByteMarauderStrong
- IronCompilerStrong
- StackCycloneStrong
- KernelRampageStrong
- ScriptSpartanStrong
- scriptmasonUnique
- gitgadgetUnique
- stacksprinterUnique
- devdynamoUnique
- pixelpioneerUnique
- algorhythmUnique
- pixelbyteShort
- stackpilotShort
- gitcraftShort
- scriptwaveShort
- compilehubShort
- algomintShort
- codecruncherClever
- bitbenderClever
- looplifterClever
- gitgobblerClever
- stacksplicerClever
- compilecaperClever
- branchbiscuitClever
- repo-riderClever
- merge-museClever
- byteMaverickCool
- stackJoltCool
- gitFuryCool
- npmRogueCool
- hexCrafterCool
- logicSpireCool
- compileRushCool
- scriptViperCool
- codebananaFunny
- bugsproutFunny
- pixelpuddingFunny
- gitgiggleFunny
- npmnutterFunny
- functorfizzFunny
- looplollipopFunny
- stackspoonFunny
- compilecactusFunny
- debugdoughnutFunny
- codecraftBest
- bitwaveBest
- gitgazerBest
- stackmasonBest
What is a developer nickname?
A developer nickname is a chosen handle that identifies one programmer across the accounts where their code and their arguments live. It is typed by other people, read aloud in review calls, and carried from one employer to the next, which is why it outlives almost everything else a developer picks.
Three different things get called a developer’s name, and only one of them is this page’s subject.
- The job title
- Software engineer, site reliability engineer, platform engineer. This is what you are called. An employer assigns it, it changes when you change roles, and you do not choose it.
- The company or studio name
- The name a business trades under. It belongs to an organisation rather than a person, it is registered rather than claimed, and it is a different naming object that this page does not cover.
- The username or handle
- The string you pick once and then carry across GitHub, GitLab, npm, a package registry and a forum. It is the only one of the three governed by published rules that can refuse it.
This page means the third unless it says otherwise. Because the third kind is the one a platform can reject, a candidate is worth generating first and checking second, in that order, and the rest of the page follows that sequence: how the names here were built, what the platforms allow, what happens if you rename, and how to pick between the ones that survive.
How does this developer nickname generator work?
It asks a language model for candidate names in the tone selected and returns ten at a time. Seven tones exist, each cached separately, so pressing again for a tone that has already been generated costs nothing and answers instantly, while a genuinely new tone spends one call. The canonical set refreshes on a cadence rather than on every visit.
Two limits are worth stating plainly, because most name tools leave them implied. It does not check whether a username is taken on GitHub, GitLab, npm or anywhere else. It cannot, because that check needs live access to each platform’s account registry. You perform it yourself by opening github.com/<name>, gitlab.com/<name> and npmjs.com/~<name> and seeing whether a profile loads.
One rule it does enforce: every name it returns matches the character rule GitHub publishes, which is letters and digits and single hyphens only, 2 to 39 characters, no leading or trailing hyphen and no doubled hyphen. Nothing on this page is a string GitHub would refuse, which is not something a list of decorated nicknames can say.
Developer nickname ideas, grouped by how each one was built
This page carries 303 developer nicknames in seven groups, and each group is built by a different construction method that is named in that group’s first sentence. All 303 are valid GitHub usernames exactly as typed, checked against GitHub’s published character rule, so none of them is a string the platform would reject. None of them is availability checked, because a name that is legal is not the same as a name that is free. Every one was generated for this page and then checked against the extracted text of all nine pages ranking for this query on 13 September 2026, so nothing here is a name the niche already carries.
Cool developer names
These 42 join one real part of a running computer to one noun for a person who does a job, so the name states what you act on instead of what mood you are in. The machine noun carries the whole weight: KernelSmith says something ShadowSmith does not, because only one of the two names a thing that exists in the reader’s day.
- KernelSmith
- SocketKeeper
- BufferWarden
- CachePilot
- ThreadScout
- PacketRanger
- DaemonCourier
- CursorHerald
- LedgerCutter
- BeaconRunner
- AnchorTender
- IndexWeaver
- SignalSentry
- LanternBroker
- CompassDrover
- SpindleHarrier
- RelayMarshal
- GirderSteward
- LatticeRider
- RegisterWatcher
- PipelineTamer
- ClusterDrover
- GatewayKeeper
- PayloadCutter
- ChecksumScout
- ManifestSmith
- SnapshotRunner
- BitmaskWarden
- SandboxTender
- BastionPilot
- FirewallSentry
- TerminalCourier
- ConsoleHerald
- ClipboardWeaver
- SchedulerRanger
- DispatcherBroker
- WatchdogMarshal
- HeartbeatRider
- BootloaderSteward
- FirmwareWatcher
- WaveformTamer
- AirlockHarrier
Software developer nicknames
These 39 join a real software noun to the name of a pre-industrial trade, which turns the handle into a claim about workmanship rather than a claim about power. The trade words are a closed set of roughly twenty, including wright, cooper, fletcher, chandler, glazier, joiner, turner and binder, so pairing each with a different software noun produces names that are rare without being invented, and none of them needs a digit appended to be free.
- CompileWright
- RefactorCooper
- SchemaFletcher
- RuntimeChandler
- SyntaxGlazier
- BinaryJoiner
- LexiconTurner
- GrammarBinder
- StackPotter
- HeapTanner
- BranchMiller
- CommitCarver
- PatchThatcher
- BuildBrewer
- LintFarrier
- TraceCobbler
- SpoolMason
- ShimSawyer
- ParserFuller
- LinkerWainwright
- CodecCurrier
- LoaderCollier
- MapperChapman
- RouterBaxter
- CipherWebster
- DigestLorimer
- EmitterCooper
- ReducerWright
- IteratorFletcher
- PointerGlazier
- OpcodeJoiner
- BytecodeTurner
- RegistryBinder
- NamespacePotter
- MigrationTanner
- FixtureMiller
- RollbackCarver
- ToolchainThatcher
- ChangelogBrewer
Funny developer nicknames
These 45 compress one thing that really goes wrong while writing software into a handle, so the joke is something any working developer has lived through rather than a word that merely sounds silly. A joke handle earns nothing if it needs explaining, so each name points at a single named failure, an off-by-one error, a Friday deploy, a detached HEAD, instead of stacking a funny-sounding adjective onto a technical noun.
- off-by-one
- WorksOnMyBox
- ItCompiles
- ShipItFriday
- RebasedTwice
- ForgotTheSemi
- CachedForever
- FlakyByDesign
- MergedToMain
- StillRebasing
- NamingIsHard
- CacheOrCrash
- SilentCatchAll
- LastKnownGood
- ReadTheLogs
- ItWorkedLocally
- PushedToProd
- ForceWithLease
- DetachedHead
- ReviewLater
- SquashAndPray
- HotfixHero
- RollbackReady
- TabsNotSpaces
- SemverOptional
- WorksAsIntended
- ReproOnMyMachine
- StaleBranch
- PendingReview
- AlmostThreadSafe
- EventuallyConsistent
- NotANumber
- CatchAndIgnore
- RetryUntilTrue
- SleepThenHope
- CommentedOutCode
- TemporaryFix2021
- MagicNumberSeven
- ZeroIndexedLife
- LeftPadSurvivor
- RegexReadOnce
- TimezoneVictim
- WorksInStaging
- InfiniteWhileTrue
- TwoHardThings
Developer nickname ideas by programming language
These 48 take one real feature of a single language or runtime and turn it into a name for the person who works in it, so the handle says which stack you live in without spelling the language out. Google’s AI Overview for this query offers Gopher and Pythonista as examples, but neither is a name: both are the established community demonyms for the users of a language, so they identify the language and not the person. Every name here encodes a feature instead, a borrow checker, a channel that has been closed, significant indentation, a monadic bind, which is what makes it yours rather than the language’s.
- BorrowChecked
- LifetimeElided
- MovedNotCopied
- OwnsItsMemory
- UnsafeBlockOnly
- ChannelClosed
- DeferredAlways
- SelectOnChannels
- NilInterface
- IndentedTwice
- DunderMethod
- ListComprehended
- DecoratedTwice
- GlobalLockHeld
- MonadicBind
- LazilyEvaluated
- CurriedTwice
- PureByDefault
- MallocAndPray
- FreedTwice
- PointerMath
- NullTerminated
- StackAllocated
- BalancedParens
- MacroExpanded
- CarAndCdr
- LetItCrash
- SupervisedTree
- HotCodeSwap
- CallbackNested
- PromiseChained
- ClosureCaptured
- HoistedVar
- TripleEquals
- ThisIsUndefined
- InnerJoined
- CoveringIndex
- PipedToGrep
- SetPipefail
- RedirectedStderr
- RegisterSpill
- ZeroFlagSet
- GarbageCollected
- CheckedException
- MonkeyPatched
- RaiiScoped
- MoveSemantics
- TemplateHeavy
Short developer usernames
These 45 are four to seven letters, one syllable or two, with no digits and no hyphen, so the whole handle is typed into a terminal or a chat window without looking down. Four to seven is legibility guidance and nothing more: Google’s overview says to keep a handle short and states no figure at all, no platform enforces a minimum beyond GitLab’s two characters, and the only enforced length anywhere on this page is GitHub’s published maximum of 39. The honest cost is scarcity. A five-letter handle on a platform as old as GitHub is very likely already claimed, so this is the group where you should expect to check several before one is free.
- Quill
- Brass
- Latch
- Flint
- Cinder
- Hatch
- Rivet
- Gable
- Plume
- Shard
- Thorn
- Verge
- Taper
- Crank
- Knurl
- Mould
- Parch
- Quoin
- Trawl
- Vane
- Wedge
- Yoke
- Axle
- Bight
- Cairn
- Dowel
- Flume
- Graft
- Helix
- Ingot
- Jolt
- Loom
- Nudge
- Oriel
- Purl
- Rasp
- Sleet
- Thrum
- Baste
- Glint
- Torque
- Brisk
- Tiller
- Quern
- Whittle
One-word developer pseudonyms
These 40 are single invented words shaped like ordinary surnames, never two English words stuck together, which is what lets a pseudonym read as a person rather than as a job description. The convention is real and the AI Overview points at it directly: its own Pseudonyms bucket names working solo developers who publish under one coined word rather than a compound handle. A coined word does carry one risk that a compound does not, so search it before you adopt it. In the r/gamedev thread Google itself cites, a commenter warned the original poster that his chosen name Animus would make people think of Assassin’s Creed.
- Ambrell
- Bardow
- Cresland
- Denhart
- Eskil
- Farlowe
- Gunnard
- Haverly
- Ingersall
- Jorsted
- Kelstow
- Larkfield
- Marrowby
- Nestrom
- Oakhurst
- Pellman
- Quarrow
- Redding
- Salbeck
- Tarvin
- Ulmstead
- Varnell
- Welbourne
- Yarwell
- Zellick
- Brannock
- Chadmere
- Draycott
- Endicott
- Forsbey
- Garrow
- Hallowby
- Ivorson
- Jessup
- Kendlow
- Lombard
- Merrow
- Norbury
- Ostend
- Pyrford
Developer handles for GitHub and npm
These 44 are two lower-case words joined by a single hyphen, which is the one shape that is a legal username on GitHub, GitLab and npm at the same time with nothing changed between them. The reason sits in three separate documents: npm’s own account documentation requires a username to be lower case, GitHub’s own documentation allows only alphanumeric characters and dashes, and GitLab’s own profile documentation allows letters, digits, underscores, hyphens and periods while forbidding a leading hyphen. Lower-case letters plus single interior hyphens is what survives all three. A CamelCase handle from the groups above is legal on GitHub and GitLab and has to be lowercased for npm; every name in this group is usable on all three without editing.
- birch-rebase
- cedar-deploy
- willow-query
- heather-diff
- bramble-blame
- thistle-stash
- harbour-tag
- meadow-hook
- quarry-seed
- cobble-render
- gravel-fetch
- driftwood-bundle
- saltmarsh-minify
- lowtide-hoist
- kestrel-mount
- heron-yield
- otter-spawn
- badger-fork
- teasel-clone
- comfrey-squash
- rowan-vendor
- alder-lockstep
- hazel-lockfile
- juniper-cherry
- larch-migrate
- sycamore-inspect
- poplar-bisect
- aspen-reflog
- nettle-rollup
- furze-linting
- marram-checkout
- tussock-rewrite
- bracken-reload
- clover-restore
- fennel-resolve
- mallow-refetch
- yarrow-observe
- nutmeg-encode
- pumice-decode
- basalt-verify
- slate-publish
- chalk-release
- loam-package
- shale-install
What are the username rules on GitHub, GitLab and npm?
GitHub allows 39 characters, GitLab allows 2 to 255, and npm allows no capital letters at all, so the three platforms a developer most wants one handle on agree on almost nothing. Each rule below was read from that platform’s own documentation on 13 September 2026.
| Platform | Maximum length | Characters allowed | What the platform’s own document states |
|---|---|---|---|
| GitHub | 39 characters | Alphanumeric characters and dashes | GitHub’s own documentation states that usernames “can only contain alphanumeric characters and dashes” and “must not exceed 39 characters”, and that a normalized username cannot start or end with a dash and cannot contain two consecutive dashes. |
| GitLab | 255 characters, minimum 2 | Non-accented letters, digits, underscore, hyphen, period | GitLab’s own profile documentation states a username “must be between 2 and 255 characters in length” and “must only include non-accented letters, digits, _, -, and .“, and must not start with an underscore, a hyphen or a period. |
| npm | Not stated | Lower-case letters, hyphens, numerals | npm’s own account documentation states that a username “must be lower case, and can contain hyphens and numerals”. It states no length limit at all. |
Put the three together and one shape survives all of them: a handle made of lower-case letters, digits and single interior hyphens, 39 characters or fewer, is legal on GitHub, GitLab and npm without being edited between them. That is narrower than any of the three rules taken alone, and it is the reason the handle group above looks the way it does.
One platform is missing from that table on purpose. Stack Overflow publishes no display-name policy page: its documented URL returns “Page not found” to both a crawler and a logged-out browser, checked on 13 September 2026. An unconfirmed limit is worth less than no limit, so no Stack Overflow rule appears anywhere on this page.
What happens to your old username after you rename?
Your old username does not stay yours. GitHub’s own documentation on changing your username states that “after changing your username, your old username becomes available for anyone else to claim”. GitHub does automatically redirect references to your repositories from the old name, but the same document states that the redirect is overridden “if the new owner of your old username creates a repository with the same name as your repository”.
Some things do survive a rename. That document also states that commits associated with another email address already added to your account continue to be attributed to you and continue to appear in your contributions graph.
This is where the standard advice comes apart. Google’s AI Overview for this query tells the reader to check availability by searching GitHub, X and Reddit, which describes a one-time lookup. GitHub’s own document describes a handle that can be lost and a link that can be broken after you give it up. Availability and ownership are different questions, and only the second one matters a year later.
GitLab behaves similarly and says so. Its own profile documentation states that a username carries a unique namespace which is updated when the username changes, advises reading how redirects behave before renaming, and suggests creating a new user or group and transferring projects to it instead of renaming at all.
The consequence is simple enough to state as a rule: a handle is worth choosing carefully because changing it later is not free, which is what the next section is for.
How do you choose between developer nickname candidates?
Run six checks, in this order, and stop at the first failure. The reason this section exists rather than a longer list is the problem the sources actually describe: the r/gamedev thread that Google’s own AI Overview cites was opened by a developer who wrote that he had been “waiting the last 2 years” for a name to arrive. The shortage is not of candidates. It is of a way to decide between them.
- Say it out loud to someone who cannot see it spelled. In that same thread, a team that settled on the name Gauge drew an immediate objection from another commenter: “gauge is not intuitive to pronounce for non-native speakers.” A handle is heard before it is read in every code review call you will ever join.
- Search the candidate on its own, before anything else. A commenter in the same thread warned the original poster that people would assume Assassin’s Creed from the name Animus. An unintended association costs nothing to find today and a package rename to find later.
- Check it against all three character rules at once. Use the table above. A name that is perfectly legal on GitHub is illegal on npm for a single capital letter, and that failure appears only at the moment you try to publish.
- Open the three profile URLs and see whether a page loads. Try
github.com/<name>,gitlab.com/<name>andnpmjs.com/~<name>. This is the only availability check that exists, and no generator on this query performs it, including the one on this page. - Ask whether it still fits after a stack change. This is the AI Overview’s own “think long-term” tip made concrete: a handle naming one language dates itself the day you change languages, which is exactly why the language group above encodes a feature rather than a language name.
- Check that it carries no personal data. No legal surname, no birth year, no employer, no city. A handle is more public and more permanent than the account it sits on, and all four of those survive every rename you will ever do.
Six checks. A candidate that survives all six is worth claiming on all three platforms in the same sitting, because the gap between deciding and registering is the only window in which someone else takes it.
What do developers actually call themselves?
Developers have called themselves four different things in seventy years, and the word changed every time the job did. Writing in InfoWorld on 17 December 2025, in a column titled “What developers call themselves”, Nick Hodges traces the sequence.
- Operator. The people who programmed the first computers did it by plugging wires into sockets, setting switches and turning dials. Hodges writes that they called themselves operators “because they physically operated the machine”, since there was no separation between the machine and the logic running on it.
- Programmer. The term arrived only with the abstraction of a computer language, which for the first time separated the logic of a program from the device executing it.
- Developer. Once code became modular, reusable and versioned, the work stopped being only the writing of code, and the older word stopped covering it.
- Software engineer. The term that came with boundaries, modules and interfaces, and the one Hodges says has largely displaced programmer, which he calls “a bit old-fashioned”.
The column is an opinion piece and marks its own position clearly: Hodges writes that he has never liked the term software engineering, and that he considers software development an art rather than a science.
The history is useful rather than decorative. The noun this profession uses for itself is the oldest naming decision in the field and it is still moving, which is the strongest argument available for a handle that names what you do to a machine rather than one that names the job title you hold this year.
Why do the top-ranked developer nickname lists not work as usernames?
The page ranking first for this query offers names that no developer platform will accept. Checked on 13 September 2026, the number-one organic result is a nickname page for the word Developer whose entries are almost entirely symbol-decorated spellings of that same word, assembled from characters outside the Latin alphabet and from combining marks stacked onto ordinary letters.
That is a fact rather than a matter of taste, and the check is one line long. GitHub’s published rule allows only alphanumeric characters and dashes. Every one of those decorated strings fails it, so none of them can be a GitHub, GitLab or npm username at all. A reader who arrives wanting a handle leaves with a string that cannot be registered anywhere they intend to use it.
The register fails too, and the developers themselves say so. In the r/gamedev thread Google’s own overview cites, the community’s summary of the floor is that nobody minds what you call yourself “as long as it’s not xX_Y0LO-GAMEDEV-XzZx”. The decorated handle is the thing this audience is actively avoiding, not the thing it is searching for.
One genuinely useful number does come out of the list sites, and it is worth stating precisely. mynickname.com publishes statistics for the nicknames registered on its own site under the tag Developer, and reports an average length of 8.08 characters, with 88 percent of them a single word. That is the site’s own measurement of its own users rather than an industry figure, but it points the same way the platform rules do: eight characters and one word is where people who actually register developer handles end up, which is why the short group here stops at seven letters and the pseudonym group is one word.
Frequently asked questions about developer nicknames
Ten questions, taken from the People Also Ask set captured with this query on 13 September 2026 and from the forum threads Google’s own overview cites, each rephrased rather than copied.
Is a developer nickname the same as a job title?
No. A job title is assigned by an employer and changes when your role changes, while a developer nickname is chosen once by you and carried between employers. Site reliability engineer is a title; a handle on GitHub is a name. The two are confused often enough that several answers to this question on the ranking pages list job titles rather than names, which answers a question the searcher did not ask.
Can a developer nickname contain numbers?
Yes on all three platforms. GitHub’s own documentation allows alphanumeric characters, GitLab’s own documentation allows digits, and npm’s own account documentation states a username can contain numerals. Whether a number is a good idea is a separate question: a digit appended to an otherwise taken name records that somebody else registered it first, which is why none of the 303 names on this page uses one that way.
What makes a developer nickname hard to use on a team?
Being unpronounceable, because a handle is said out loud in review calls far more often than it is typed. The clearest statement of the problem comes from the r/gamedev thread Google’s overview cites, where a team that chose the name Gauge was told immediately that it “is not intuitive to pronounce for non-native speakers”. A handle that two colleagues say differently is a handle that stops being one name.
What is a cool developer name?
A cool developer name is one that names something real in the machine and needs no explanation, which in practice means a compound of a computing noun and an agent noun, like the 42 in the cool group above. The negative test is the more useful half: a name stops being cool the moment it needs a digit appended to be free, because the digit announces that the name was somebody else’s first.
How long can a developer username be?
GitHub’s own documentation caps a username at 39 characters, GitLab’s own documentation allows 2 to 255, and npm’s own account documentation states no length limit at all. Build to 39 characters or fewer and the name is inside every published limit on all three platforms at once.
Can you change your developer username later?
Yes on all three platforms, but the old handle does not stay reserved for you. GitHub’s own documentation states that after a change the old username “becomes available for anyone else to claim”, and that its automatic redirect stops working if the new owner creates a repository with the same name as one of yours.
Should a developer nickname include your real name?
No, and the reason is that a handle is more public and more permanent than the account it sits on. The two things to leave out specifically are a birth year and a legal surname, because both survive every rename and both are searchable forever. The one legitimate exception is deliberate: a developer publishing under their own reputation may want their surname in the handle, which is a decision to make once rather than by accident.
What is a fancy word for a developer?
The profession’s own words for itself, in the order they arrived, are operator, programmer, developer and software engineer, a sequence Nick Hodges traces in InfoWorld on 17 December 2025. Engineer is the current formal term and programmer is the one Hodges calls old-fashioned, so a handle that avoids all four of them ages better than one that picks a side.
Can a developer nickname be the same on GitHub, GitLab and npm?
Yes, if it is lower-case letters, digits and single interior hyphens, 39 characters or fewer, which is the intersection of the three platforms’ published rules. One capital letter makes it illegal on npm, and one underscore or period makes it illegal on GitHub, which is why the handle group above uses neither.
Does a name generator check whether a username is available?
No, and the generator on this page does not either. Availability lives inside each platform’s own account registry, which a language model cannot read, so no tool answering this query can tell you whether a handle is free. The check that does work takes about twenty seconds: open the profile URL on each of the three platforms and see whether a page loads.
Three neighbouring decisions are worked through elsewhere on this site. The privacy argument for a handle that encodes nothing about you, and what a single reused username gives away, is the whole subject of the random username generator page. The same character-rule problem in its strictest form, a platform that permits lower case only, is on the Discord names page. And the version of this question for a project rather than a person, where the string has to survive DNS as well as a platform’s account rules, is on the website name generator page. In every one of them the finding is the same as it is here: a developer nickname that is legal is still not a developer nickname that is free, and GitHub will tell you the first but never the second.
