TRENDSHIFT #22 · 2026.06.11

Creators-of-Create/Create 딥다이브
— 마인크래프트 안에 "회전 동력 공학"을 통째로 구현한 모드

마인크래프트(Minecraft)에 톱니바퀴·축·벨트로 동력을 전달하는 기계 장치를 더하는 NeoForge 모드다. 단순히 블록만 추가한 게 아니라, 회전 속도(RPM)부하(Stress)를 실시간으로 계산하는 물리 동력 네트워크, 블록 덩어리를 통째로 움직이는 구조물(Contraption) 엔진, GPU 인스턴싱 렌더러(Flywheel), 게임 안 인터랙티브 설명서(Ponder)까지 갖춘 대규모 Java 시뮬레이션 코드베이스다. 그래서 이 레포는 "마인크래프트 모드 만들기"를 넘어 그래프 기반 시뮬레이션·실시간 렌더링·대규모 OOP 설계를 배우는 실전 교본이다. (저장소: Creators-of-Create/Create · ★4.2k · Fork 1.3k · 5,462 commits · Java 100% · NeoForge 21.1.219 · MC 1.21.1 · v6.0.11 · 커스텀 라이선스 · TrendShift 22위)
목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 구조 해부
  6. 학습 포인트 (기술별)
  7. 하드웨어 / 시스템 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

이 레포가 무엇을 하는 물건인가.

핵심 메시지

"마인크래프트 위에 올린 미니 공장 시뮬레이터 —
수차가 돌면 축·톱니·벨트를 타고 동력이 흐르고, 기계가 일을 한다."

바닐라 마인크래프트의 자동화는 대부분 레드스톤 신호(0/1)로 끝난다. Create는 거기에 "얼마나 빠르게 도는가(속도)"와 "얼마나 무거운 일을 시키는가(부하)"라는 아날로그 축을 더한다. 수차·풍차·증기기관이 동력을 만들고, 그 동력이 축과 톱니바퀴를 따라 흐르며, 압착기·믹서·드릴 같은 기계가 그 동력을 소비해 아이템을 가공한다. UI 창을 여는 대신 눈에 보이는 기계 장치(contraption)를 직접 조립하는 게 이 모드의 정체성이다.

Create(mod_id: create)는 simibubi가 시작해 "Creators of Create" 팀이 유지하는 NeoForge 모드다. 핵심은 "건축·장식·미적 자동화(Building, Decoration, and Aesthetic Automation)"로, 플레이어에게 정해진 정답 기계가 아니라 부품을 조합해 자기만의 장치를 설계할 자유를 준다. 코드 관점에서 보면 이건 마인크래프트라는 틱(tick) 기반 게임 루프 위에 올린 거대한 실시간 시뮬레이션 + 렌더링 엔진이다.

이 저장소(Creators-of-Create/Create)는 NeoForge판이고, 별도의 Fabric판(Fabricators-of-Create/Create)이 따로 있다. 기본 브랜치 이름이 mc1.21.1/dev인 데서 보이듯, 마인크래프트 버전별로 브랜치를 나눠 관리한다. 5,400개가 넘는 커밋과 1,100개 이상의 열린 이슈는 이 프로젝트가 살아 있는 대형 OSS임을 말해 준다.

용어
모드(Mod) · NeoForge · Fabric
모드는 게임 코드에 끼어들어 콘텐츠·동작을 바꾸는 확장 프로그램. 마인크래프트 자바판은 직접 모딩을 지원하지 않아, 모드 로더가 필요하다. NeoForgeFabric은 양대 모드 로더로, 게임에 후킹 포인트(이벤트·레지스트리)를 열어 준다. Create는 둘 다 지원하되 코드베이스가 갈라져 있다.
용어
틱(tick)
마인크래프트의 시간 단위. 서버는 초당 20틱(50ms마다 1틱)으로 세상을 갱신한다. Create의 모든 동력 계산·기계 동작·구조물 이동은 이 틱 루프 안에서 조금씩 진행된다. "초당 20번 호출되는 tick() 안에서 무엇을, 얼마나 가볍게 계산하느냐"가 모드 성능의 핵심 제약이다.

2왜 주목받는가

트렌딩 이유 · 다른 기술 모드 대비 장점.

Create는 출시 이후 마인크래프트 기술 모드(tech mod) 장르에서 손꼽히는 인기작이 됐고, 거대 모드팩의 단골 핵심 모드다. 2026년 들어 MC 1.21.1 + NeoForge로의 이식과 6.x 대형 릴리스(물류/패키지 시스템 확장)가 맞물리며 다시 주목을 받는다. 코드를 공부하는 입장에서 매력 포인트는 넷이다.

비교 항목전형적 레드스톤 자동화다른 기술 모드(에너지형)Create
동력 모델신호 on/off숫자 에너지(RF/FE)속도(RPM)+부하(SU) 2축
상호작용회로 배선케이블·파이프눈에 보이는 축·톱니·벨트
자동화 단위고정 블록고정 기계움직이는 구조물(엔티티화)
학습 방식위키가이드북 아이템게임 내 Ponder 씬
매력 ① — 신호가 아니라 "물리량"을 시뮬레이션한다
속도(RPM)와 부하(Stress)의 2축 모델

대부분의 자동화는 0/1 신호나 단순 에너지 숫자로 끝난다. Create는 회전 속도와 부하 용량을 따로 계산한다. 발전기는 "부하 용량(stress capacity)"을 공급하고, 기계는 속도에 비례해 "부하(stress impact)"를 소비한다. 용량보다 소비가 크면 네트워크 전체가 과부하로 멈춘다. 게임 규칙이 곧 작은 물리 엔진이라, 코드로 보면 흥미로운 그래프 시뮬레이션이다.

매력 ② — 블록 덩어리가 통째로 "움직인다"
Contraption — 정적 블록을 동적 엔티티로

도르래·피스톤·베어링·기차에 붙은 블록 묶음은 게임 도중 하나의 움직이는 엔티티로 변신한다. 정적인 월드 블록을 런타임에 "떼어내" 이동·회전시키고, 멈추면 다시 월드에 심는다. 마인크래프트의 블록/엔티티 경계를 넘나드는 이 트릭은 모드 개발에서 가장 어려운 영역 중 하나다.

매력 ③ — 자체 렌더링 엔진을 끼워 넣었다
Flywheel — GPU 인스턴싱으로 수천 개 부품을 그린다

회전하는 축·톱니가 화면에 수백~수천 개 떠도 60fps를 유지하려면 바닐라 렌더링으로는 부족하다. Create 팀은 인스턴스 렌더링 엔진 Flywheel을 별도 라이브러리로 분리해, 같은 모델을 GPU에 한 번 올리고 인스턴스 데이터(위치·회전각)만 바꿔 대량 렌더한다. 게임 모드가 그래픽스 최적화까지 끌고 가는 드문 사례.

매력 ④ — 설명서를 게임 안에 코드로 짰다
Ponder — 스크립트로 움직이는 인터랙티브 튜토리얼

위키 대신, 각 기계의 작동 원리를 게임 내 3D 씬으로 시연하는 Ponder 시스템을 만들었다. 씬 하나하나가 "블록을 놓고 → 강조하고 → 회전시키고 → 자막을 띄우는" 스크립트다. 이것도 별도 라이브러리(net.createmod.ponder)로 분리돼, 다른 모드도 가져다 쓸 수 있다.

비유

레고 테크닉 세트. 일반 레고(레드스톤)가 "붙였다/뗐다"라면, 레고 테크닉(Create)은 모터·기어·축으로 실제 회전 동력을 전달하는 키트다. 모터(발전기)가 약한데 무거운 기계를 잔뜩 물리면 전체가 안 돌아가는 것까지 똑같다. Create는 이 "물리적으로 말이 되는 기계 조립"의 손맛을 코드로 구현한 것이다.

3기술 스택 전체 지도

언어/런타임 · 모드 플랫폼 · 핵심 라이브러리 · 빌드 인프라의 4축으로 본다.

Create는 서버/프론트가 나뉜 웹앱이 아니라, 마인크래프트 클라이언트·서버 양쪽에서 도는 단일 Java 모드다. 그래서 "백/프론트" 대신 게임 런타임 + 모드 플랫폼 + 의존 라이브러리 + 빌드 도구 관점으로 스택을 그리는 게 정확하다. 모든 설정은 gradle.properties에 깔끔히 모여 있다.

① 언어 · 런타임

분류스택역할
언어Java 100% (Java 21)MC 1.21.1은 Java 21 위에서 동작
게임Minecraft 1.21.1모드가 올라가는 베이스
매핑Parchment 2024.11.17난독화된 MC 코드에 사람이 읽는 이름 부여
용어
매핑(mappings) · Parchment
마인크래프트 자바판은 출시 시 코드가 난독화되어 변수·메서드 이름이 a, b, c처럼 의미 없다. 매핑은 이를 사람이 읽을 수 있는 이름으로 되돌리는 사전이다. Parchment는 거기에 파라미터 이름·주석까지 입혀 주는 커뮤니티 매핑으로, 모드 개발 경험을 크게 개선한다.

② 모드 플랫폼 — NeoForge

neo_version = 21.1.219. NeoForge는 Forge에서 갈라져 나온 모드 로더로, 레지스트리·이벤트 버스·네트워킹·데이터 생성(datagen) 같은 모딩 인프라를 제공한다. Create의 메인 클래스 Create.java@Mod(Create.ID) 애너테이션으로 시작하고, IEventBus에 각종 등록 콜백을 건다.

③ 핵심 의존 라이브러리 — 에코시스템 핵심 라이브러리 4종

주목할 점: Create는 자기 기능 일부를 독립 라이브러리로 떼어내 다른 모드도 쓰게 공개했다. build.gradle의 의존성이 곧 이 모드의 야심을 보여준다.

라이브러리버전역할
RegistrateMC1.21-1.3.0블록·아이템 등록을 빌더 DSL로 간결화 (tterrag 제작)
Flywheel1.0.6GPU 인스턴스 렌더링 엔진 (engine-room/jozufozu)
Ponder1.0.82게임 내 씬 기반 설명서 프레임워크 (createmod.net)
Vanillin1.1.3-41Flywheel로 바닐라 엔티티/블록을 그리는 구현
Catnip(임포트로 확인)공용 유틸(폰트·언어·수학) — net.createmod.catnip

④ 선택적 연동(compat) · 빌드 인프라

런타임 필수는 아니지만 연동을 위해 localImplementation 또는 compileOnly로 물린 모드가 많다: JEI(레시피 뷰어 — localImplementation으로 로컬 컴파일+런타임 전용), Curios(장신구 슬롯), Sodium(렌더 최적화), CC: Tweaked(인게임 컴퓨터 — 기계를 Lua로 제어), Farmer's Delight(요리). 빌드는 Gradle(build.gradle + NeoForge 플러그인)로 하고, Jenkinsfile로 CI를, crowdin.yml로 다국어 번역을 관리한다.

용어
compileOnly · jarJar · localRuntimeOnly
Gradle 의존성 범위. compileOnly는 "컴파일할 때만 참고, 배포엔 미포함"(연동 모드의 API만 빌림). jarJar는 "내 jar 안에 이 라이브러리를 동봉"(Registrate·Ponder처럼 사용자가 따로 안 깔아도 되게). localRuntimeOnly는 "개발 중 테스트 실행에만" 쓴다. 이 구분이 모드 배포의 핵심 노하우다.

4아키텍처 심화 분석

동력 네트워크 → 구조물 → 렌더링, 세 기둥을 차례로 해부한다.

4-1. 큰 그림 — 콘텐츠 / 기반 / API의 3층 분리

코드를 열면 com.simibubi.create 아래가 역할별로 깔끔히 갈린다. 이 패키지 분리 자체가 첫 번째 학습 포인트다.

com.simibubi.create ├─ content/ # 실제 게임 기능 (kinetics, contraptions, trains, logistics…) ├─ foundation/ # 공용 기반 (blockEntity, render, gui, networking, utility…) ├─ api/ # 안정적 확장 지점 (다른 모드가 의존해도 되는 공개 인터페이스) ├─ infrastructure/ # 설정·명령어·데이터생성·월드젠·게임테스트 ├─ compat/ # 타 모드 연동 (jei, curios, sodium, computercraft…) └─ impl/ # api의 내부 구현체

content(기능) ↔ foundation(공통 토대) ↔ api(외부 계약)를 나눠 두면, 기능이 수백 개로 불어나도 토대 코드는 한 곳에 모이고, 외부 모드가 의존할 면(api)이 명확해진다. "바뀌는 것(content)과 안 바뀌어야 하는 것(api)을 분리"하는 대형 코드베이스의 정석이다.

4-2. 기둥 ① 운동 동력 네트워크 (Kinetics)

모드의 심장. content/kinetics/ 아래에 수차(waterwheel)·풍차·증기기관(steamEngine)·기어박스(gearbox)·압착기(press)·믹서(mixer)·드릴(drill)·벨트(belt) 등 30여 종의 부품이 들어 있고, 모두 KineticBlockEntity를 상속한다.

핵심 아이디어: 서로 연결된 회전 부품들은 하나의 KineticNetwork로 묶인다. 이 네트워크가 두 가지를 계산한다 — 속도(RPM)는 부품 사이를 전파되고(톱니비에 따라 곱/나눗셈), 부하(Stress)는 "공급 용량 vs 소비량"으로 합산된다.

[발전기] [전달] [소비 기계] ┌──────────┐ 회전 전파 ┌──────────┐ 속도/방향 ┌──────────┐ │ 수차/풍차 │ ─────────▶ │ 축·톱니바퀴 │ ─────────▶ │ 압착기/믹서 │ │ 증기기관 │ │ (gearbox) │ │ 드릴/벨트 │ └────┬─────┘ └──────────┘ └─────┬────┘ │ 부하 용량(+SU) 공급 │ 부하(-SU) 소비 ▼ ▼ ┌──────────────────────────────────────────┐ │ KineticNetwork │ │ sources : Map<BE, Float> (용량 제공자) │ │ members : Map<BE, Float> (모든 구성원) │ │ calculateCapacity() vs calculateStress()│ │ → 소비 > 용량 이면 "과부하"로 전체 정지 │ └──────────────────────────────────────────┘

실제 KineticNetwork.java를 보면 sources(용량 공급자)와 members(전체 구성원)를 각각 Map<KineticBlockEntity, Float>로 들고, calculateCapacity()calculateStress()를 합산해 비교한다. 속도가 빠를수록 부하도 커지도록 getStressMultiplierForSpeed(speed)를 곱한다.

// content/kinetics/KineticNetwork.java (요약) — 네트워크의 두 장부
public class KineticNetwork {
  public Map<KineticBlockEntity, Float> sources; // 용량 제공자
  public Map<KineticBlockEntity, Float> members; // 전체 구성원

  public float calculateCapacity() { // 공급 용량 합 ... }
  public float calculateStress()   { // 소비 부하 합 ... }

  // 속도가 빠를수록 용량·부하에 곱해지는 배수
  private static float getStressMultiplierForSpeed(float speed) { ... }
}

그렇다면 "누가 누구와 연결됐는지"는 어떻게 알까? 그 역할이 RotationPropagator(이웃으로 회전을 전파하고 속도/방향 충돌을 감지)와 TorquePropagator(틱마다 네트워크를 갱신)다. 블록을 놓거나 부수면 이 전파기가 네트워크를 다시 잇거나 끊는다.

용어
BlockEntity (블록 엔티티)
단순 블록은 "여기 무슨 블록"이라는 ID만 갖지만, BlockEntity는 그 블록에 추가 데이터와 매 틱 로직을 붙인다(예: 회전 속도, 인벤토리). Create의 모든 기계는 KineticBlockEntity(= BlockEntity 하위)다. 과거 "타일 엔티티(Tile Entity)"로 불렸다.
용어
Stress Unit (SU, 부하 단위) · 과부하(Overstress)
발전기가 공급하는 부하 용량과 기계가 소비하는 부하의 단위. 한 네트워크의 총 소비가 총 용량을 넘으면 과부하가 되어 회전이 멈춘다. 현실의 "모터 토크 한계"를 게임 규칙으로 옮긴 것. 속도를 올리면 처리량은 늘지만 부하도 함께 커지는 트레이드오프가 핵심 재미다.

4-3. 기둥 ② 구조물 엔진 (Contraptions)

content/contraptions/. 베어링(bearing)·피스톤(piston)·도르래(pulley)·갠트리(gantry)·엘리베이터(elevator)·광산수레(minecart)가 공통으로 하는 일: 붙어 있는 블록 묶음을 "구조물(Contraption)"로 포착해 움직이는 엔티티로 바꾸고, 멈출 때 다시 월드 블록으로 되돌린다.

조립(assemble) 이동/회전 해체(disassemble) ┌─────────────────┐ ┌──────────────────────────┐ ┌─────────────────┐ │ 월드에 박힌 정적 │ │ ContraptionEntity 로 변신 │ │ 다시 월드 블록으로 │ │ 블록들 (Block) │──▶│ · 블록 데이터를 메모리에 보관 │──▶│ 심는다 (재배치) │ │ + 베어링/피스톤 등 │ │ · 가상 월드에서 통째로 이동 │ │ │ └─────────────────┘ │ · Flywheel 로 한 덩어리 렌더 │ └─────────────────┘ └──────────────────────────┘

이때 "떼어낸 블록들"은 임시 가상 월드(virtualWorld)에 담겨 상호작용(예: 이동하는 작업대 위 톱이 나무를 자르는 것)을 그대로 유지한다. foundation/virtualWorld/가 그 토대다. 정적 블록 ↔ 동적 엔티티를 오가는 이 설계가 Create에서 가장 정교한 부분이다.

4-4. 기둥 ③ 렌더링 — BlockEntity 렌더러 vs Flywheel

회전체를 그리는 길이 두 갈래다. 바닐라 방식인 KineticBlockEntityRenderer(매 프레임 지오메트리 재생성)와, 인스턴싱 방식인 KineticBlockEntityVisual + RotatingInstance(Flywheel). Flywheel이 켜져 있으면 같은 축 모델을 GPU에 한 번 올리고 인스턴스별 회전각만 갱신해 수천 개를 싸게 그린다. Flywheel이 없거나 꺼지면 자동으로 바닐라 렌더러로 폴백한다.

비유 — 인스턴싱이 왜 빠른가

도장 vs 손그림. 똑같은 톱니바퀴 1,000개를 그릴 때, 바닐라는 매 프레임 1,000번을 일일이 손으로 그린다(CPU↔GPU 왕복 폭증). Flywheel은 도장(모델)을 GPU에 한 번 새겨두고, "여기, 이 각도로 1,000번 찍어"라는 위치·각도 목록만 넘긴다. 그려야 할 게 많아질수록 격차가 벌어진다.

설계 패턴 ① — 등록 DSL (Registrate)

수백 개의 블록·아이템을 일일이 손으로 레지스트리에 등록하면 코드가 폭발한다. Create는 AllBlocks·AllItems 같은 클래스에서 Registrate의 빌더 체인으로 "블록 + 아이템 형태 + 모델 + 전리품표 + 태그"를 한 선언에 묶는다. 반복을 라이브러리로 흡수한 사례.

설계 패턴 ② — Behaviour 합성

foundation/blockEntity/behaviour/. 기계의 능력(아이템 입출력, 부하 표시, 유체 처리 등)을 상속이 아니라 탈착식 Behaviour 객체로 조립한다. "is-a"(상속)가 아닌 "has-a"(합성)로 기능을 붙여, 수십 종 기계가 능력을 자유롭게 섞는다.

설계 패턴 ③ — 글로벌 매니저 + 그래프(기차)

content/trains/의 철도는 선로를 그래프(graph/)로 모델링하고, GlobalRailwayManager가 전 세계 열차·신호·시간표를 총괄한다. 신호(signal)·관측기(observer)·스케줄(schedule)이 맞물린, 사실상 작은 교통 시뮬레이터다.

흔한 오해
"마인크래프트 모드 = README대로 블록 몇 개 추가" — 천만에

Create는 블록을 "추가"하는 수준이 아니라, 게임 루프 위에 동력 시뮬레이션·엔티티 변환·커스텀 렌더 파이프라인을 얹은 엔진이다. 그래서 README만 읽으면 절대 이해할 수 없고, content/kinetics/KineticNetworkRotationPropagator로 이어지는 실제 코드를 따라가야 구조가 보인다. 이 문서가 그 지도를 그려 준다.

5디렉토리 구조 해부

저장소 전체 → 소스 패키지 → 동력 부품 폴더 순으로 좁혀 본다.

5-1. 저장소 전체

Create/ (branch: mc1.21.1/dev) ├─ src/ │ ├─ main/java/ # 모드 본체 (com.simibubi.create) │ ├─ main/resources/ # 텍스처·모델·레시피·언어 등 에셋/데이터 │ ├─ main/templates/ # 빌드 시 값이 주입되는 mods.toml 등 템플릿 │ └─ generated/ # datagen 으로 자동 생성된 리소스(전리품·모델…) ├─ build.gradle # 의존성·빌드 정의 (NeoForge 플러그인) ├─ gradle.properties # 모든 버전 한곳에 (MC·NeoForge·Flywheel…) ├─ settings.gradle # 개발 시 Ponder 소스 동시 빌드(includeBuild) ├─ Jenkinsfile # CI 파이프라인 ├─ crowdin.yml # 번역(다국어) 관리 └─ LICENSE.md # 커스텀 라이선스
관찰 — gradle.properties 한 장이 곧 기술 명세서

이 모드의 전체 버전 매트릭스가 gradle.properties 한 파일에 다 적혀 있다(MC·NeoForge·Parchment·Registrate·Ponder·Flywheel·JEI·Curios·Sodium·CC:Tweaked…). 낯선 대형 레포를 만나면 README보다 이 빌드 설정 파일을 먼저 읽는 것이 기술 스택을 파악하는 가장 빠른 길이다.

5-2. 소스 본체 main/java/com/simibubi/create/

패키지역할
content/게임 기능 전부. kinetics·contraptions·trains·logistics·processing·decoration·equipment·redstone·fluids·schematics
foundation/공용 토대. blockEntity(+behaviour)·render·gui·networking·fluid·data·virtualWorld·utility·mixin
api/외부 공개 계약. contraption·stress·boiler·packager·schematic·connectivity·behaviour 등 확장 지점
infrastructure/config(설정)·command·data(datagen)·worldgen·gametest·ponder
compat/타 모드 연동: jei·curios·sodium·computercraft·farmersdelight·ftb
Create.java@Mod 진입점. 모든 등록 콜백을 이벤트 버스에 연결하는 부트스트랩

5-3. 동력 부품 폴더 content/kinetics/ 내부

각 기계가 자기 폴더를 갖는 기능별(feature-folder) 구조다 — 부품 하나를 이해하려면 그 폴더만 보면 된다.

content/kinetics/ ├─ base/ # KineticBlockEntity, IRotate, 렌더/비주얼 공통 토대 ├─ KineticNetwork.java / RotationPropagator.java / TorquePropagator.java ├─ waterwheel/ steamEngine/ flywheel/ # 발전기(용량 공급) ├─ gearbox/ simpleRelays/ transmission/ speedController/ # 전달·변속 ├─ press/ mixer/ crusher/ millstone/ saw/ drill/ deployer/ # 가공 기계 ├─ belt/ chainDrive/ chainConveyor/ # 이송 ├─ crank/ motor/ turntable/ gantry/ mechanicalArm/ # 기타 액추에이터 └─ gauge/ # 속도계/응력계 (StressGaugeBlockEntity)

읽는 순서 추천: base/KineticBlockEntity.java(모든 기계의 부모) → ② KineticNetwork.java(네트워크 장부) → ③ RotationPropagator.java(연결·충돌 판정) → ④ waterwheel/(용량을 공급하는 쪽) → ⑤ press/(부하를 소비하는 쪽). 이 다섯이면 동력 시스템 전체가 잡힌다.

6학습 포인트 (기술별)

이 레포 하나로 "시뮬레이션 + 렌더링 + 대형 OOP 설계"를 동시에 챙긴다.

① 그래프 기반 실시간 시뮬레이션

가장 값진 배움. 서로 연결된 노드(기계)들을 네트워크로 묶고, 상태(속도·부하)를 전파·합산하며 매 틱 갱신하는 패턴은 회로 시뮬레이터·유체 네트워크·전력망 등 어디서나 쓰인다. 블록을 놓고 부술 때 네트워크를 증분 갱신(전체 재계산 회피)하는 RotationPropagator의 기법이 특히 실전적이다.

실습: KineticNetwork.javacalculateCapacity()·calculateStress()를 읽고, "속도를 2배로 올리면 부하 용량과 소비가 각각 어떻게 변하는지"를 getStressMultiplierForSpeed 기준으로 설명해 보기.

② 틱 예산(tick budget) 안에서의 성능 사고

초당 20틱, 즉 한 틱은 50ms 안에 세상 전체 갱신이 끝나야 한다. "매 틱 전부 재계산"하면 큰 공장에서 렉이 걸린다. Create는 네트워크를 캐싱하고 변경분만 갱신하며, 렌더는 Flywheel로 GPU에 떠넘긴다. "비싼 계산을 어떻게 분산·캐시·오프로드하나"를 실물로 배운다.

실습: TorquePropagator가 매 틱 무엇을 하는지 추적하고, "왜 모든 네트워크를 매 틱 처음부터 계산하지 않는가"를 한 문단으로 정리.

③ 합성(composition) over 상속(inheritance)

수십 종 기계가 능력을 공유하는데, 거대한 상속 트리 대신 foundation/blockEntity/behaviour/탈착식 Behaviour로 조립한다. "상속의 다이아몬드 지옥"을 합성으로 피하는 OOP 설계 원칙을 대규모 코드에서 본다.

실습: 기계 BE 하나를 골라 addBehaviours(...)로 어떤 Behaviour들이 붙는지 나열하고, 같은 Behaviour를 공유하는 다른 기계를 찾아보기.

④ 정적 데이터 ↔ 동적 엔티티 변환

Contraption은 월드에 박힌 블록을 런타임에 엔티티로 "들어 올렸다" 다시 내려놓는다. 직렬화(블록→데이터)·가상 월드·재배치의 한 사이클을 보면, 게임 외 분야에서도 "상태 스냅샷을 떠서 이동·복원"하는 패턴의 감을 얻는다.

⑤ GPU 인스턴스 렌더링 입문

같은 메시를 대량으로 그릴 때 인스턴싱이 왜·어떻게 빠른지를 RotatingInstance/KineticBlockEntityVisual로 구체적으로 본다. 게임 그래픽스의 핵심 최적화를 실코드로 만나는 드문 기회다(원리는 일반 OpenGL/Vulkan 인스턴싱과 동일).

⑥ 대형 OSS 운영 — datagen · 다국어 · CI

전리품표·모델·태그 수천 개를 손으로 안 쓰고 infrastructure/data/데이터 생성기(datagen)로 자동 출력한다(src/generated/). 번역은 Crowdin, 빌드는 Jenkins, 게임 동작 검증은 gametest/로 한다. 실전 OSS 운영 교본.

7하드웨어 / 시스템 요구사항

"플레이"와 "개발(코드 빌드)"의 요구사항이 다르다.

구분항목요구사항 / 메모
플레이게임Minecraft Java 1.21.1 + NeoForge 21.1.219
JavaJava 21 런타임 (MC 1.21.x 기준)
그래픽Flywheel 인스턴싱 활용 권장 — 큰 공장일수록 GPU·RAM 여유 필요
개발JDKJDK 21 (빌드·실행 모두)
빌드 도구Gradle (저장소의 gradlew 래퍼 사용 — 별도 설치 불필요)
메모리gradle.properties-Xmx3G 지정 — 빌드에 3GB 권장
IDEIntelliJ IDEA 권장(.idea/ 동봉) · Parchment 매핑으로 가독성↑

소스에서 빌드/실행

# 1) 저장소 클론 (개발 브랜치)
git clone -b mc1.21.1/dev https://github.com/Creators-of-Create/Create

# 2) 개발용 클라이언트 실행 (gradlew 래퍼가 NeoForge 환경 구성)
./gradlew runClient      # Windows: gradlew.bat runClient

# 3) 배포용 jar 빌드 → build/libs/ 에 생성
./gradlew build

# 4) datagen 재생성 / 인게임 게임테스트
./gradlew runData
./gradlew runGameTestServer

처음 실행은 NeoForge·MC·매핑·의존 모드를 내려받느라 시간이 걸린다. settings.gradlePonder/ 디렉토리가 있으면 Ponder 소스도 함께 빌드되도록 includeBuild가 걸려 있어, 라이브러리까지 한 번에 수정·디버깅할 수 있다.

8직접 해볼 수 있는 실습 과제

읽기만 말고, 난이도순으로 손을 움직여 보자.

Lv1. 인게임으로 모델 감 잡기 입문 · 1시간

모드를 설치해 수차 → 축 → 압착기를 직접 연결하고, 응력계(stress gauge)·속도계를 달아 속도·부하 숫자가 어떻게 변하는지 관찰한다. 발전기 하나에 기계를 계속 추가해 "과부하로 멈추는 순간"을 재현. 코드를 읽기 전 도메인 직관을 먼저 만든다.

Lv2. gradle.properties 해독 + 빌드 초급 · 반나절

레포를 클론해 ./gradlew runClient로 개발 클라이언트를 띄운다. gradle.properties의 모든 버전 항목이 무엇인지 한 줄씩 주석을 달고, build.gradle에서 compileOnly·jarJar·localRuntimeOnly가 각각 어떤 의존에 쓰였는지 분류해 본다.

Lv3. KineticNetwork 코드 추적 중급 · 1일

base/KineticBlockEntity.javaKineticNetwork.javaRotationPropagator.java 순으로 읽으며 "블록을 놓으면 네트워크가 어떻게 합쳐지고, 부수면 어떻게 갈라지는지"를 호출 흐름도로 그린다. 로그를 찍어 실제 합산값을 눈으로 확인.

Lv4. 아주 단순한 동력 부품 추가 중상급 · 2~3일

기존 단순 부품(예: simpleRelays의 축류)을 본떠, 속도를 그대로 통과시키는 새 블록 하나를 AllBlocks에 Registrate로 등록하고 모델·텍스처·언어 파일까지 붙여 인게임에 띄운다. datagen으로 전리품·모델을 자동 생성해 본다.

Lv5. 미니 Ponder 씬 작성 고급 · 3~5일

내가 추가한 블록에 대해 "놓고 → 강조하고 → 회전시키고 → 자막 띄우는" Ponder 씬 스크립트를 작성해, 게임 안에서 W키로 설명서가 재생되게 만든다. 선언적 씬 DSL을 다뤄 보며 Create의 "코드로 짠 설명서" 철학을 체득.

9관련 기술 심화 학습 로드맵

4주 코스 — 모딩 기초와 코드 독해를 번갈아 다진다.

주차주제핵심 활동
1주차마인크래프트 모딩 기초NeoForge 환경 구성 · 블록/아이템/BlockEntity 개념 · 레지스트리·이벤트 버스 이해 · 빈 모드 띄우기(Lv2)
2주차BlockEntity & 틱 루프KineticBlockEntity 읽기 · tick() 안의 일 · NBT 직렬화/동기화 · 클라/서버 분리 개념(Lv1·Lv3)
3주차동력 네트워크 & 합성 설계KineticNetwork·RotationPropagator 정독 · Behaviour 합성 패턴 분석 · 단순 부품 추가(Lv4)
4주차렌더링 & 콘텐츠 도구Flywheel 인스턴싱 개념 · BlockEntityRenderer vs Visual · Ponder 씬 작성 · datagen 활용(Lv5)
학습 순서의 이유

먼저 "모드가 게임에 어떻게 끼어드는가"(1주)와 "블록에 로직을 붙이는 BlockEntity"(2주)를 알아야, 3~4주차에 Create의 동력 네트워크와 렌더 코드가 "왜 이렇게 생겼는지" 납득된다. 마인크래프트라는 무대 규칙(틱·레지스트리·클라/서버)을 먼저 깔고, 그 위의 Create 고유 설계로 올라가는 순서다.

10핵심 키워드 사전

이 레포를 읽다 마주치는 용어들.

용어
Kinetics (운동 동력)
Create의 회전 동력 시스템 전체를 가리키는 패키지/도메인. 속도(RPM)와 부하(SU)를 다루는 모든 부품(content/kinetics/)이 여기 속한다.
용어
KineticBlockEntity
모든 회전 기계의 부모 BlockEntity. 자기 속도·소속 네트워크를 들고 매 틱 갱신된다. 발전기는 GeneratingKineticBlockEntity로 한 단계 더 파생된다.
용어
KineticNetwork
연결된 부품들의 묶음. sources(용량 제공자)와 members(전 구성원) 맵을 들고 총 용량·총 부하를 합산·비교한다. 소비>용량이면 과부하.
용어
RotationPropagator / TorquePropagator
전자는 이웃으로 회전(속도·방향)을 전파하고 충돌을 감지해 네트워크를 잇거나 끊는다. 후자는 틱마다 네트워크 상태를 갱신·관리한다.
용어
Stress / Capacity (SU)
기계가 소비하는 부하와 발전기가 공급하는 용량. 속도가 빠를수록 둘 다 커진다(getStressMultiplierForSpeed). 처리량과 부하의 트레이드오프가 게임플레이의 핵심.
용어
Contraption (구조물)
베어링·피스톤·도르래 등으로 조립된 블록 묶음이 변신한 움직이는 엔티티. 가상 월드에 블록 데이터를 담아 이동·회전하고, 멈추면 다시 월드 블록으로 재배치된다.
용어
Flywheel (렌더 엔진)
Create 팀이 분리한 GPU 인스턴스 렌더링 라이브러리(dev.engine-room.flywheel). 같은 모델을 한 번 올리고 인스턴스 데이터만 바꿔 대량 렌더. 부품명과 헷갈리지 말 것 — 동력 부품 flywheel(관성 바퀴)과는 별개.
용어
Ponder
게임 안에서 기계 작동 원리를 3D 씬으로 시연하는 인터랙티브 설명서 프레임워크(net.createmod.ponder). 씬은 "놓기·강조·회전·자막"을 잇는 스크립트다. 별도 라이브러리로 공개.
용어
Registrate
블록·아이템·BE를 빌더 체인으로 한 번에 등록하는 라이브러리(tterrag). AllBlocks·AllItems가 이를 써서 "블록+아이템+모델+전리품+태그"를 한 선언으로 묶는다.
용어
BlockEntity (구 Tile Entity)
블록에 데이터와 매 틱 로직을 붙이는 객체. 단순 블록은 ID만, BlockEntity는 인벤토리·속도 같은 상태와 동작을 가진다. Create 기계의 기반.
용어
datagen (데이터 생성)
전리품표·모델·태그·레시피 같은 JSON 리소스를 코드로 자동 생성하는 NeoForge 기능. 수천 개를 손으로 안 쓰고 ./gradlew runDatasrc/generated/에 출력한다.
용어
Mixin
바닐라 클래스의 바이트코드에 끼어들어 동작을 바꾸는 모딩 기법(foundation/mixin/). 게임 원본 코드를 직접 수정하지 않고 후킹하기 위해 쓴다.

11참고 링크

원본과 더 깊이 파고들 자료.

프로젝트 원본

· GitHub 저장소(NeoForge): github.com/Creators-of-Create/Create
· Fabric 포트: github.com/Fabricators-of-Create/Create
· CurseForge: curseforge.com/.../create · Modrinth: modrinth.com/mod/create
· 위키 / Discord: 저장소 상단 링크(r.createmod.net) 참고

코드 안에서 먼저 볼 곳

· 진입점: src/main/java/com/simibubi/create/Create.java
· 동력 핵심: content/kinetics/base/KineticBlockEntity.java, content/kinetics/KineticNetwork.java, RotationPropagator.java
· 구조물: content/contraptions/ · 렌더: content/kinetics/base/KineticBlockEntityVisual.java
· 버전 매트릭스: gradle.properties · 의존성: build.gradle

배경 지식

· NeoForge 공식 문서: docs.neoforged.net (블록/아이템/BlockEntity/datagen)
· Parchment 매핑: parchmentmc.org
· Flywheel(렌더): github.com/Engine-Room/Flywheel · GPU 인스턴싱 개념 학습 병행 권장