---

The Complete Guide to Building a D&D Character in 8th

Learn to build a Dungeons & Dragons character generator in the 8th programming language. This guide covers generating ability scores by simulating dice rolls, calculating modifiers, and structuring character data using 8th's unique stack-based approach, from random number generation to final hitpoint calculation.

After weeks of anticipation, the day is finally here. You and your friends are gathered around the table, snacks are ready, and the adventure awaits. It's time for your very first game of Dungeons & Dragons. But as the Dungeon Master begins to set the scene, a cold wave of panic washes over you. The first task is character creation, which requires dice. Lots of dice. And you, the person who organized this whole event, completely forgot to bring them.

Your friends look at you expectantly. The excitement in the room is slowly turning into awkward silence. But then, an idea sparks. You're a programmer. You don't need physical dice; you can create them with code. This isn't a problem; it's an opportunity—a chance to solve a real-world dilemma with the power of logic and a unique, powerful language. In this guide, we'll turn that moment of panic into a triumph by building a complete D&D character generator using 8th, a fascinating stack-based language. By the end, you'll not only save your game night but also gain a deep understanding of 8th's core principles.

---

What is a D&D Character Generator? The Core Mechanics

Before we dive into the code, it's crucial to understand the rules we're trying to model. In Dungeons & Dragons, a character is defined by a set of core attributes that influence everything they can do in the game. Our generator will focus on the foundational elements of a new character.

The Six Core Ability Scores

Every character possesses six fundamental abilities. These scores typically range from 3 to 18 for a starting character and represent their raw talent and prowess in different areas.

• Strength (STR): Represents physical power and brute force.
• Dexterity (DEX): Measures agility, reflexes, and balance.
• Constitution (CON): Signifies health, stamina, and vital force.
• Intelligence (INT): Determines reasoning, memory, and analytical skill.
• Wisdom (WIS): Reflects awareness, intuition, and insight.
• Charisma (CHA): Governs influence, persuasion, and force of personality.

The "4d6 Drop Lowest" Method

The most common method for determining these scores, and the one we will implement, is known as "4d6 drop the lowest." The process is simple yet provides a degree of randomness and favorability:

1. Roll Dice: For a single ability score, you roll four six-sided dice (4d6).
2. Drop the Lowest: You look at the four results and discard the single lowest roll.
3. Sum the Rest: You add the values of the remaining three dice together. This sum becomes the ability score.
4. Repeat: You repeat this entire process six times, once for each of the six abilities.

Hit Points and the Constitution Modifier

A character's initial health, or Hit Points (HP), is determined by their resilience, which is directly tied to their Constitution score. A higher Constitution means a hardier character. The calculation involves a "modifier," a value derived from an ability score.

The formula for any ability modifier is: (Ability Score - 10) / 2, rounded down. For our character's initial hitpoints, the formula is 10 + Constitution Modifier. This gives every character a base of 10 HP plus a bonus (or penalty) from their Constitution.

---

Why Use 8th for This Task? A Stack-Based Approach

You might wonder why we're choosing 8th, a relatively niche language, for this task instead of something more mainstream like Python or JavaScript. The answer lies in its paradigm. 8th is a concatenative, stack-based language, which offers a unique and powerful way to think about data manipulation.

In 8th, most operations work by taking values from a central data structure called "the stack," performing an action, and pushing the result back onto the stack. This leads to extremely concise and expressive code, especially for tasks involving a sequence of data transformations, just like our character generation logic.

This project, part of the exclusive kodikra.com 8th curriculum, is perfectly designed to highlight 8th's strengths. It forces you to think about program flow as a series of transformations on a stack of data, providing a profound learning experience that is hard to replicate in other languages.

Pros and Cons of This Approach

Aspect	Pros	Cons
Code Conciseness	8th code is incredibly dense and expressive. Complex logic can be written in just a few lines.	The "point-free" style can be difficult for beginners to read and debug without understanding the stack's state.
Learning Experience	Forces a deep understanding of data flow and functional composition. Excellent for expanding your programming mindset.	The learning curve is steep if you've only ever worked with traditional imperative or object-oriented languages.
Performance	8th is designed for speed and efficiency, often outperforming many high-level scripting languages.	For a simple script like this, the performance difference is negligible and not the primary reason for its selection.
Extensibility	Defining new "words" (functions) is trivial, making it easy to build a library of reusable components.	The ecosystem and third-party libraries are much smaller compared to mainstream languages.

---

How the Character Generation Logic is Implemented in 8th

Now, let's break down the logic step-by-step and see how each piece of the D&D rules translates into 8th's stack-based operations. We will build our solution from the smallest components upwards, a common and effective strategy in concatenative languages.

Step 1: Calculating an Ability Modifier

The first piece of logic we need is a function to calculate an ability modifier from a score. The formula is (score - 10) / 2, rounded down. In 8th, integer division naturally handles the "round down" part.

Our modifier word will expect a number (the ability score) on the stack and leave a new number (the modifier) on the stack. This is often documented as ( n -- n ).

: modifier \ n -- n
  10 n:- 2 n:/mod nip ;

• : modifier: Defines a new word named modifier.
• \ n -- n: A comment indicating the stack effect: it consumes one number and produces one number.
• 10 n:-: Pushes 10 onto the stack, then the n:- word subtracts the top item (10) from the second item (the score). The result is left on the stack.
• 2 n:/mod: Pushes 2 onto the stack. The n:/mod word performs integer division and calculates the modulus. It leaves the remainder on top of the stack and the quotient (our desired result) below it.
• nip: This is a crucial stack shuffling word. It "nips" the second item from the stack, effectively dropping the remainder from our division and leaving only the quotient.

Step 2: Simulating a Dice Roll

Next, we need to simulate rolling a single 6-sided die. 8th has a built-in word for generating a random number within a range.

: roll \ -- n
  1 6 rand-range ;

• : roll: Defines the word roll.
• \ -- n: The stack effect comment shows it consumes nothing and produces one number.
• 1 6: Pushes the numbers 1 and 6 onto the stack, representing our minimum and maximum values.
• rand-range: Consumes the min and max values from the stack and pushes a single random integer between them (inclusive).

Step 3: Finding the Sum of the Highest Rolls

This is the core of the "4d6 drop lowest" logic. We need a word that takes an array of four numbers, finds the three highest, and sums them. We can achieve this by sorting the array, removing the first (lowest) element, and then summing the rest.

First, let's create helper words for finding the highest rolls and for summing an array.

: highest-rolls \ a -- a
  ' n:cmp a:sort a:shift ;

: sum \ a -- n
  ' n:+ 0 a:reduce ;

• : highest-rolls: Defines a word that expects an array (a) and leaves a modified array on the stack.
• ' n:cmp: Pushes the word n:cmp (a number comparison word) to the stack. This will be used by the sort function.
• a:sort: Sorts the array on top of the stack using the comparison word we just provided. The array is now sorted in ascending order.
• a:shift: Removes and returns the first element of the array. Since the array is sorted, this is the lowest number. Crucially, it leaves the modified array (with the 3 highest numbers) on the stack.

• : sum: Defines a word that takes an array (a) and returns a single number (n).
• ' n:+: Pushes the addition word n:+ to the stack.
• 0: Pushes the initial value for our sum, 0.
• a:reduce: A powerful higher-order function. It applies the n:+ word to each element of the array, accumulating the result starting with 0. This effectively sums all elements in the array.

Step 4: Generating a Single Ability Score

Now we can combine our building blocks to create a word that performs the full "4d6 drop lowest" sequence.

: ability \ -- n
  ' roll 4 times       \ Roll a d6 four times, leaving 4 numbers on the stack
  4 a:close            \ Collect the top 4 numbers into an array
  highest-rolls        \ Sort the array and remove the lowest element
  drop                 \ Drop the returned lowest element, keeping the modified array
  sum                  \ Sum the elements of the remaining array
;

This word is a beautiful example of 8th's compositional nature. Let's trace the stack:

1. ' roll 4 times: Executes the roll word four times. The stack now has four random numbers, e.g., [ ... 5 2 6 4 ].
2. 4 a:close: Takes the top 4 items from the stack and puts them into a new array. The stack is now [ ... [5, 2, 6, 4] ].
3. highest-rolls: Operates on this array. It sorts it to [2, 4, 5, 6], then uses a:shift. a:shift returns the shifted element (2) and leaves the modified array [4, 5, 6]. The stack is now [ ... [4, 5, 6] 2 ].
4. drop: We don't care about the lowest value that was returned, so we simply drop it from the stack. The stack is now [ ... [4, 5, 6] ].
5. sum: Our sum word consumes the array and leaves its sum on the stack. The stack is now [ ... 15 ]. The result is a single, valid ability score.

Here is a visual representation of the logic flow for generating a single ability score:

    ● Start
    │
    ▼
  ┌───────────┐
  │ Execute   │
  │ 'roll'     │
  │ 4 times   │
  └─────┬─────┘
        │
        ▼
  ┌───────────┐
  │ Collect   │
  │ rolls into│
  │ an array  │
  └─────┬─────┘
        │
        ▼
  ┌───────────┐
  │ Sort the  │
  │ array     │
  │ ascending │
  └─────┬─────┘
        │
        ▼
  ┌───────────┐
  │ Remove    │
  │ lowest    │
  │ value     │
  └─────┬─────┘
        │
        ▼
  ┌───────────┐
  │ Sum the   │
  │ remaining │
  │ 3 values  │
  └─────┬─────┘
        │
        ▼
    ● End (Ability Score)

---

Where the Final Character is Assembled: A Full Code Walkthrough

With all the components in place, we can now write the final word, character, which will generate a complete character sheet with all six abilities and the calculated hitpoints. We'll store this data in an 8th map (similar to a dictionary or hash map).

The Complete Solution Code

needs rand/range

\ Calculate the D&D ability modifier for a given score
: modifier \ n -- n
  10 n:- 2 n:/mod nip ;

\ Simulate rolling a single 6-sided die
: roll \ -- n
  1 6 rand-range ;

\ Given an array of rolls, sort it and remove the lowest value
: highest-rolls \ a -- a' n
  ' n:cmp a:sort a:shift ;

\ Sum all numbers in an array
: sum \ a -- n
  ' n:+ 0 a:reduce ;

\ Generate a single ability score using the "4d6 drop lowest" method
: ability \ -- n
  ' roll 4 times 4 a:close highest-rolls drop sum ;

\ Generate a complete character map with 6 abilities and hitpoints
: character \ -- m
  m:new                                \ Create a new, empty map
  "strength" ability m:!             \ Generate score and add to map
  "dexterity" ability m:!            \ ...
  "intelligence" ability m:!         \ ...
  "wisdom" ability m:!               \ ...
  "charisma" ability m:!             \ ...
  ability                            \ Generate Constitution score, leave it on the stack
  dup                                \ Duplicate it. Stack: [ ... con con ]
  modifier                           \ Calculate modifier. Stack: [ ... con modifier ]
  10 n:+                             \ Calculate HP. Stack: [ ... con hp ]
  -rot                               \ Rotate stack. Stack: [ ... hp con ]
  "constitution" swap m:!            \ Add constitution. Stack: [ ... hp ]
  "hitpoints" rot m:!                \ Add hitpoints.
;

Dissecting the `character` Word

The character word is where the magic happens. It's a masterclass in stack manipulation to efficiently build our final data structure.

1. m:new: Creates a new empty map and pushes it to the stack. The stack now holds [ map ].
2. "strength" ability m:!: This sequence is repeated for five abilities.
   • "strength": Pushes the key string to the stack. Stack: [ map "strength" ].
   • ability: Calls our ability word, generating a score. Stack: [ map "strength" 15 ].
   • m:!: The "map set" word. It consumes the map, key, and value from the stack, adds the key-value pair to the map, and pushes the modified map back. Stack: [ map' ].
3. ability: This time, we generate the Constitution score but we don't immediately put it in the map. We leave it on the stack because we need it for the hitpoint calculation. Stack: [ map con_score ].
4. dup: Duplicates the top item on the stack. We need one copy of the Constitution score to store in the map and another to calculate the modifier. Stack: [ map con_score con_score ].
5. modifier: Calculates the modifier from the top copy of the score. Stack: [ map con_score con_modifier ].
6. 10 n:+: Calculates the hitpoints. Stack: [ map con_score hitpoints ].
7. -rot: This is a "reverse rotate" stack shuffle. It moves the third item on the stack to the top. Stack: [ hitpoints map con_score ]. This is a clever move to get the values in the right order for the final map insertions.
8. "constitution" swap m:!:
   • "constitution": Pushes the key. Stack: [ hitpoints map con_score "constitution" ].
   • swap: Swaps the top two items. Stack: [ hitpoints map "constitution" con_score ].
   • m:!: Sets the constitution score in the map. Stack: [ hitpoints map' ].
9. "hitpoints" rot m:!:
   • "hitpoints": Pushes the key. Stack: [ hitpoints map' "hitpoints" ].
   • rot: Rotates the top three items. The top item goes to the third position. Stack: [ map' "hitpoints" hitpoints ].
   • m:!: Sets the hitpoints in the map. Stack: [ map'' ].

The word finishes, leaving the final, fully populated character map on top of the stack, ready to be used or printed.

This entire process can be visualized as a high-level workflow:

    ● Start
    │
    ▼
  ┌────────────────┐
  │ Create New Map │
  └────────┬───────┘
           │
           ├───────────────────┐
           │                   │
           ▼                   ▼
  ┌────────────────┐ ┌────────────────┐
  │ Gen. Ability   │ │ Gen. Ability   │
  │ Score (x5)     │ │ Score (CON)    │
  └────────┬───────┘ └────────┬───────┘
           │                   │
           ▼                   │
  ┌────────────────┐           │
  │ Add to Map     │           │
  └────────┬───────┘           │
           │                   │
           └─────────┬─────────┘
                     │
                     ▼
  ┌──────────────────────────────────┐
  │ Use CON score to calculate HP    │
  └──────────────────┬───────────────┘
                     │
                     ▼
  ┌──────────────────────────────────┐
  │ Add CON score & HP to Map        │
  └──────────────────┬───────────────┘
                     │
                     ▼
    ● End (Character Map)

To run this code, you would save it as a file (e.g., dnd.8th) and execute it with the 8th interpreter. You could add a final . (print) command after calling character to see the output in your terminal.

# In your terminal
$ 8th -f dnd.8th -e "character ."

# Example Output:
# M{"strength":14, "dexterity":12, "intelligence":15, "wisdom":11, "charisma":16, "constitution":13, "hitpoints":11}

---

Frequently Asked Questions (FAQ)

What is 8th and why is it called a stack-based language?

8th is a modern, cross-platform programming language inspired by Forth. It's called "stack-based" because its primary method of data manipulation is a Last-In, First-Out (LIFO) stack. Instead of assigning values to variables and passing them to functions, you push values onto the stack and then execute "words" (functions) that operate directly on that stack.

How is the Constitution modifier calculated in D&D?

The official rule for any ability modifier in Dungeons & Dragons 5th Edition is to subtract 10 from the ability score and then divide the result by 2, rounding down. For example, a Constitution score of 13 would result in a modifier of +1 ( (13 - 10) / 2 = 1.5, rounded down to 1).

Can I customize the character generation rules in this 8th code?

Absolutely. The code is highly modular. If you wanted to use a different rolling method, like "3d6", you would simply modify the ability word to ' roll 3 times 3 a:close sum ;. The composable nature of the code makes such changes very straightforward.

What do `nip` and `-rot` do on the 8th stack?

These are powerful stack shuffling words. nip (from A+ programming language) removes the second item from the top of the stack. If the stack is [ a b ], after nip it becomes [ b ]. -rot (reverse rotate) moves the third item to the top. If the stack is [ a b c ], after -rot it becomes [ c a b ]. Mastering these is key to writing efficient, "point-free" 8th code.

Is this character generator compliant with official D&D rules?

Yes, the logic implemented here for generating ability scores ("4d6 drop lowest") and calculating initial hitpoints (10 + Constitution modifier) is a standard and widely used method consistent with the rules for Dungeons & Dragons 5th Edition character creation.

How can I install and run 8th to test this code?

You can download the 8th interpreter from its official website. It is available for Windows, macOS, and Linux. Once installed, you can save the code in a file with a .8th extension and run it from your terminal using the command 8th -f your_file.8th -e "character ." to execute the `character` word and print the resulting map.

What are some other fun projects to build with 8th?

8th is great for text processing, data manipulation, and building command-line tools. You could try creating a simple calculator, a file organizer, a text-based adventure game, or even web server utilities. The kodikra learning path for 8th offers many more projects to sharpen your skills.

---

Conclusion: From Panic to Power

What began as a moment of panic at the gaming table has transformed into a deep dive into a powerful and elegant programming language. By building this Dungeons & Dragons character generator, we've not only solved a practical problem but have also explored the core concepts of 8th: its stack-based nature, the power of creating and composing words, and its efficient data manipulation capabilities.

You now possess a script that can instantly generate a new character, saving your D&D night and any future sessions. More importantly, you've gained insight into a different way of thinking about programming. The skills learned in this kodikra.com module—managing the stack, composing functions, and thinking about data flow—are valuable assets that will make you a more versatile and resourceful developer.

Disclaimer: The code in this article is written for a recent, stable version of the 8th language. As the language evolves, some syntax or word behavior may change. Always refer to the official 8th documentation for the most current information.

Ready to continue your adventure? Explore the complete 8th 4 roadmap to tackle your next challenge, or see the complete 8th language guide for more in-depth tutorials.

---

Published by Kodikra — Your trusted 8th learning resource.