diff --git a/README.md b/README.md
index eeeb2ac..efa3b26 100644
--- a/README.md
+++ b/README.md
@@ -18,4 +18,7 @@ for debugging purposes.
 - `-r`: Alias for `--require`.
 - `--preferred-identifier <uri> <identifier>`: Sets the preferred identifier for a schema.
 - `-p`: Alias for `--preferred-identifier`.
-
+- `--namespace <namespace>`: Sets the default global namespace for generated files.
+- `-n`: Alias for `--namespace`.
+- `--no-namespace`: Disables generation of namespaces.
+- `-nn`: Alias for `--no-namespace`.
diff --git a/include/SyncedSchema.h b/include/SyncedSchema.h
index 28099e7..2dcb4c8 100644
--- a/include/SyncedSchema.h
+++ b/include/SyncedSchema.h
@@ -23,7 +23,7 @@ class SyncedSchema {
 public:
   using Type = IndexedSyncedSchema::Type;
   using Format = IndexedSyncedSchema::Format;
-  std::reference_wrapper<const CodeProperties> codeProperties =
+  std::reference_wrapper<const CodeProperties> codeProperties_ =
       std::cref(getDefaultCodeProperties());
 
   std::string identifier_;
@@ -68,9 +68,11 @@ class SyncedSchema {
 
   std::optional<std::vector<nlohmann::json>> examples_;
 
-  SyncedSchema(const std::string& identifier)
-      : identifier_(identifier), arrayProperties_(getTrueSchema()),
-        objectProperties_(getTrueSchema()) {}
+  SyncedSchema(
+      const std::string& identifier, const SyncedSchema& trueSchema,
+      const CodeProperties& codeProperties = getDefaultCodeProperties())
+      : codeProperties_(codeProperties), identifier_(identifier),
+        arrayProperties_(trueSchema), objectProperties_(trueSchema) {}
 
 private:
   /// @brief Private constructor to create default schemas
@@ -99,15 +101,20 @@ class SyncedSchema {
     return properties;
   }
 
-  static const SyncedSchema& getTrueSchema() {
-    static SyncedSchema schema;
-    schema.identifier_ = "True";
-    schema.definedAsBooleanSchema_ = true;
+  static std::unique_ptr<SyncedSchema> getTrueSchema(
+      const CodeProperties& codeProperties = getDefaultCodeProperties()) {
+    auto schema = std::make_unique<SyncedSchema>(SyncedSchema());
+    schema->codeProperties_ = codeProperties;
+    schema->identifier_ = "True";
+    schema->definedAsBooleanSchema_ = true;
+    schema->arrayProperties_ = ArrayProperties(*schema);
+    schema->objectProperties_ = ObjectProperties(*schema);
     return schema;
   }
 
-  static std::vector<std::unique_ptr<SyncedSchema>>
-  resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas);
+  static std::vector<std::unique_ptr<SyncedSchema>> resolveIndexedSchema(
+      std::vector<IndexedSyncedSchema>&& schemas,
+      const CodeProperties& codeProperties = getDefaultCodeProperties());
 
   static void dumpSchemas(std::vector<std::unique_ptr<SyncedSchema>>& schemas,
                           std::filesystem::path outputDirectory = ".");
diff --git a/include/SyncedSchema/ArrayProperties.h b/include/SyncedSchema/ArrayProperties.h
index 0abe398..bfadc6e 100644
--- a/include/SyncedSchema/ArrayProperties.h
+++ b/include/SyncedSchema/ArrayProperties.h
@@ -31,7 +31,8 @@ struct ArrayProperties {
   ArrayProperties(const SyncedSchema& items) : items_(items) {}
   ArrayProperties(
       const IndexedArrayProperties& arrayProperties,
-      const std::vector<std::unique_ptr<SyncedSchema>>& syncedSchemas);
+      const std::vector<std::unique_ptr<SyncedSchema>>& syncedSchemas,
+      const SyncedSchema& trueSchema);
 
   /// @brief Gets the C++ type of the array
   std::string getArrayType(std::string namespaceLocation) const;
diff --git a/src/SyncedSchema.cpp b/src/SyncedSchema.cpp
index 373cafd..4237a8f 100644
--- a/src/SyncedSchema.cpp
+++ b/src/SyncedSchema.cpp
@@ -16,9 +16,9 @@ static std::string getHeaderDefine(const SyncedSchema& schema) {
   }
   std::transform(headerDefine.begin(), headerDefine.end(), headerDefine.begin(),
                  ::toupper);
-  if (schema.codeProperties.get().definePrefix_.has_value()) {
+  if (schema.codeProperties_.get().definePrefix_.has_value()) {
     headerDefine =
-        schema.codeProperties.get().definePrefix_.value() + headerDefine;
+        schema.codeProperties_.get().definePrefix_.value() + headerDefine;
   }
   return headerDefine;
 }
@@ -29,11 +29,11 @@ static std::string getHeaderDefine(const SyncedSchema& schema) {
 /// @param schema The schema to generate the include guard for
 /// @return The generated code block
 static CodeBlock declarationIncludeGuardStart(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
 #if JSOG_DEBUG
   block << "/*" << schema.identifier_ << " include guard start*/";
 #endif
-  if (schema.codeProperties.get().headerGuardType_ ==
+  if (schema.codeProperties_.get().headerGuardType_ ==
       CodeProperties::HeaderGuard::Ifndef) {
     std::string upperFileName = getHeaderDefine(schema);
     BLOCK << std::format("#ifndef {}", upperFileName);
@@ -45,11 +45,11 @@ static CodeBlock declarationIncludeGuardStart(const SyncedSchema& schema) {
 }
 
 static CodeBlock declarationIncludeGuardEnd(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
 #if JSOG_DEBUG
   block << "/*" << schema.identifier_ << " include guard end*/";
 #endif
-  if (schema.codeProperties.get().headerGuardType_ ==
+  if (schema.codeProperties_.get().headerGuardType_ ==
       CodeProperties::HeaderGuard::Ifndef) {
     BLOCK << std::format("#endif // {}", getHeaderDefine(schema));
   }
@@ -59,14 +59,14 @@ static CodeBlock declarationIncludeGuardEnd(const SyncedSchema& schema) {
 // Namespace generation
 
 static CodeBlock namespaceStart(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
 #if JSON_DEBUG
   block << "/*" << schema.identifier_ << " namespace start*/";
 #endif
   // Global namespace, if set
-  if (schema.codeProperties.get().globalNamespace_.has_value()) {
+  if (schema.codeProperties_.get().globalNamespace_.has_value()) {
     BLOCK << std::format("namespace {} {{",
-                         schema.codeProperties.get().globalNamespace_.value());
+                         schema.codeProperties_.get().globalNamespace_.value());
   }
   // Identifier namespace
   BLOCK << std::format("namespace {} {{", schema.identifier_);
@@ -74,21 +74,21 @@ static CodeBlock namespaceStart(const SyncedSchema& schema) {
 }
 
 static CodeBlock namespaceEnd(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
 #if JSON_DEBUG
   block << "/*" << schema.identifier_ << " namespace end*/";
 #endif
   BLOCK << std::format("}} // namespace {}", schema.identifier_);
 
-  if (schema.codeProperties.get().globalNamespace_.has_value()) {
+  if (schema.codeProperties_.get().globalNamespace_.has_value()) {
     BLOCK << std::format("}} // namespace {}",
-                         schema.codeProperties.get().globalNamespace_.value());
+                         schema.codeProperties_.get().globalNamespace_.value());
   }
   return block;
 }
 
 static CodeBlock functionDeclarations(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
 #if JSOG_DEBUG
   // hoi hoi
   block << "/*" << schema.identifier_ << " function declarations*/";
@@ -114,7 +114,7 @@ static CodeBlock classForwardDeclarations(const SyncedSchema& schema) {
 #if JSOG_DEBUG
   block << "/*" << schema.identifier_ << " forward declarations*/";
 #endif
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   if (schema.type_.contains(IndexedSyncedSchema::Type::Object) ||
       schema.type_.contains(IndexedSyncedSchema::Type::Array)) {
     BLOCK << "// Forward declarations";
@@ -130,7 +130,7 @@ static CodeBlock classForwardDeclarations(const SyncedSchema& schema) {
 }
 
 CodeBlock SyncedSchema::generateDeclaration() const {
-  CodeBlock block(codeProperties.get().indent_);
+  CodeBlock block(codeProperties_.get().indent_);
 
   BLOCK << declarationIncludeGuardStart(*this);
 
@@ -155,13 +155,14 @@ CodeBlock SyncedSchema::generateDeclaration() const {
     // Object declaration
 
     if (type_.contains(IndexedSyncedSchema::Type::Object)) {
-      BLOCK << objectProperties_.objectClassDefinition(codeProperties,
+      BLOCK << objectProperties_.objectClassDefinition(codeProperties_,
                                                        getType());
     }
 
     // Array declaration
     if (type_.contains(IndexedSyncedSchema::Type::Array)) {
-      BLOCK << arrayProperties_.arrayClassDefinition(codeProperties, getType());
+      BLOCK << arrayProperties_.arrayClassDefinition(codeProperties_,
+                                                     getType());
     }
   }
 
@@ -194,7 +195,7 @@ static std::string escapeJSON(const nlohmann::json& json) {
 }
 
 static CodeBlock jsonExportFunction(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   BLOCK << std::format("std::optional<nlohmann::json> json(const {}& schema) "
                        "{{",
                        schema.getType());
@@ -213,7 +214,7 @@ static CodeBlock jsonExportFunction(const SyncedSchema& schema) {
 }
 
 static CodeBlock booleanSchemaConstruct(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   // Boolean schema means that the schema accepts either everything or nothing
   if (schema.definedAsBooleanSchema_.has_value()) {
     if (schema.definedAsBooleanSchema_.value()) {
@@ -227,11 +228,11 @@ static CodeBlock booleanSchemaConstruct(const SyncedSchema& schema) {
 }
 
 static CodeBlock refConstruct(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   if (schema.reinterpretables_.ref_.has_value()) {
     std::string namespace_;
-    if (schema.codeProperties.get().globalNamespace_.has_value()) {
-      namespace_ = "::" + schema.codeProperties.get().globalNamespace_.value();
+    if (schema.codeProperties_.get().globalNamespace_.has_value()) {
+      namespace_ = "::" + schema.codeProperties_.get().globalNamespace_.value();
     }
     namespace_ += std::format(
         "::{}", schema.reinterpretables_.ref_.value().get().identifier_);
@@ -243,7 +244,7 @@ static CodeBlock refConstruct(const SyncedSchema& schema) {
 }
 
 static CodeBlock constConstruct(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   if (schema.const_.has_value()) {
     BLOCK << std::format("if(json != \"{}\"_json) {{",
                          escapeJSON(schema.const_.value()))
@@ -255,7 +256,7 @@ static CodeBlock constConstruct(const SyncedSchema& schema) {
 static CodeBlock nullConstructor(const SyncedSchema& schema,
                                  const std::string& inputJsonVariableName,
                                  const std::string& outSchemaVariableName) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   if (schema.type_.contains(SyncedSchema::Type::Null)) {
     BLOCK << std::format("if({}.is_null()) {{", inputJsonVariableName)
           << CodeBlock::inc;
@@ -269,7 +270,7 @@ static CodeBlock nullConstructor(const SyncedSchema& schema,
 static CodeBlock stringConstructor(const SyncedSchema& schema,
                                    const std::string& inputJsonVariableName,
                                    const std::string& outSchemaVariableName) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   if (schema.type_.contains(SyncedSchema::Type::String)) {
     BLOCK << std::format("if({}.is_string()) {{", inputJsonVariableName)
           << CodeBlock::inc;
@@ -283,7 +284,7 @@ static CodeBlock stringConstructor(const SyncedSchema& schema,
 
 static CodeBlock validateConstructed(const SyncedSchema& schema,
                                      const std::string& outSchemaVariableName) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   BLOCK << std::format("if({}.has_value()) {{", outSchemaVariableName);
   {
     Indent _(block);
@@ -300,7 +301,7 @@ static CodeBlock validateConstructed(const SyncedSchema& schema,
 }
 
 static CodeBlock constructFunction(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   // Construct function
   std::string outSchemaVariableName = "outSchema";
   std::string inputJsonVariableName = "json";
@@ -330,19 +331,19 @@ static CodeBlock constructFunction(const SyncedSchema& schema) {
 
         if (schema.type_.contains(SyncedSchema::Type::Boolean)) {
           BLOCK << schema.boolProperties_.booleanConstructor(
-              schema.codeProperties, inputJsonVariableName,
+              schema.codeProperties_, inputJsonVariableName,
               outSchemaVariableName);
         }
 
         if (schema.type_.contains(SyncedSchema::Type::Integer)) {
           BLOCK << schema.numberProperties_.integerConstructor(
-              schema.codeProperties, inputJsonVariableName,
+              schema.codeProperties_, inputJsonVariableName,
               outSchemaVariableName);
         }
 
         if (schema.type_.contains(SyncedSchema::Type::Number)) {
           BLOCK << schema.numberProperties_.numberConstructor(
-              schema.codeProperties, inputJsonVariableName,
+              schema.codeProperties_, inputJsonVariableName,
               outSchemaVariableName);
         }
 
@@ -353,13 +354,13 @@ static CodeBlock constructFunction(const SyncedSchema& schema) {
 
         if (schema.type_.contains(SyncedSchema::Type::Array)) {
           BLOCK << schema.arrayProperties_.arrayConstructor(
-              schema.codeProperties, inputJsonVariableName,
+              schema.codeProperties_, inputJsonVariableName,
               outSchemaVariableName);
         }
 
         if (schema.type_.contains(SyncedSchema::Type::Object)) {
           BLOCK << schema.objectProperties_.objectConstructor(
-              schema.codeProperties, inputJsonVariableName,
+              schema.codeProperties_, inputJsonVariableName,
               outSchemaVariableName);
         }
 
@@ -377,7 +378,7 @@ static CodeBlock constructFunction(const SyncedSchema& schema) {
 }
 
 CodeBlock rawExportDefinition(const SyncedSchema& schema) {
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
   BLOCK << std::format("nlohmann::json rawExport(const {}& schema) {{",
                        schema.getType());
   {
@@ -455,7 +456,7 @@ CodeBlock rawExportDefinition(const SyncedSchema& schema) {
                    i < schema.arrayProperties_.tupleableItems_->size(); i++) {
                 const auto& item =
                     (*schema.arrayProperties_.tupleableItems_)[i].get();
-                if (schema.codeProperties.get()
+                if (schema.codeProperties_.get()
                         .minItemsMakeTupleableRequired_ &&
                     schema.arrayProperties_.minItems_.has_value() &&
                     i < schema.arrayProperties_.minItems_.value()) {
@@ -551,7 +552,7 @@ CodeBlock rawExportDefinition(const SyncedSchema& schema) {
                  i < schema.arrayProperties_.tupleableItems_->size(); i++) {
               const auto& item =
                   (*schema.arrayProperties_.tupleableItems_)[i].get();
-              if (schema.codeProperties.get().minItemsMakeTupleableRequired_ &&
+              if (schema.codeProperties_.get().minItemsMakeTupleableRequired_ &&
                   schema.arrayProperties_.minItems_.has_value() &&
                   i < schema.arrayProperties_.minItems_.value()) {
                 BLOCK << std::format(
@@ -628,7 +629,7 @@ CodeBlock rawExportDefinition(const SyncedSchema& schema) {
 
 static CodeBlock validateDefinition(const SyncedSchema& schema) {
   using Type = SyncedSchema::Type;
-  CodeBlock block(schema.codeProperties.get().indent_);
+  CodeBlock block(schema.codeProperties_.get().indent_);
 
   BLOCK << std::format("bool validate(const {}& schema) {{", schema.getType());
   {
@@ -1015,7 +1016,7 @@ static CodeBlock validateDefinition(const SyncedSchema& schema) {
 }
 
 CodeBlock SyncedSchema::generateDefinition() const {
-  CodeBlock block(codeProperties.get().indent_);
+  CodeBlock block(codeProperties_.get().indent_);
   BLOCK << std::format("#include \"{}\"", getHeaderFileName());
 
   BLOCK << namespaceStart(*this);
@@ -1043,7 +1044,7 @@ CodeBlock SyncedSchema::generateDefinition() const {
 }
 
 CodeBlock SyncedSchema::generateSystemDependencies() const {
-  CodeBlock block(codeProperties.get().indent_);
+  CodeBlock block(codeProperties_.get().indent_);
   BLOCK << "#ifndef JSOG_SYS_DEPS";
   BLOCK << "#define JSOG_SYS_DEPS";
   BLOCK << "// System dependencies"
@@ -1061,7 +1062,7 @@ CodeBlock SyncedSchema::generateSystemDependencies() const {
 }
 
 CodeBlock SyncedSchema::generateDependencies() const {
-  CodeBlock block(codeProperties.get().indent_);
+  CodeBlock block(codeProperties_.get().indent_);
   block << generateSystemDependencies();
   std::set<const SyncedSchema*> dependencies;
   if (reinterpretables_.ref_.has_value()) {
@@ -1133,9 +1134,9 @@ CodeBlock SyncedSchema::generateDependencies() const {
   bool hasForwardDeclarations = false;
   CodeBlock forwardDeclarations;
   forwardDeclarations << "// Forward declarations";
-  if (codeProperties.get().globalNamespace_.has_value()) {
+  if (codeProperties_.get().globalNamespace_.has_value()) {
     forwardDeclarations << std::format(
-        "namespace {} {{", codeProperties.get().globalNamespace_.value());
+        "namespace {} {{", codeProperties_.get().globalNamespace_.value());
   }
   for (const auto& dependency : dependencies) {
     bool hasForwardDeclaration = false;
@@ -1160,9 +1161,9 @@ CodeBlock SyncedSchema::generateDependencies() const {
       forwardDeclarations << forwardDeclaration;
     }
   }
-  if (codeProperties.get().globalNamespace_.has_value()) {
+  if (codeProperties_.get().globalNamespace_.has_value()) {
     forwardDeclarations << std::format(
-        "}} // namespace {}", codeProperties.get().globalNamespace_.value());
+        "}} // namespace {}", codeProperties_.get().globalNamespace_.value());
   }
   if (hasForwardDeclarations) {
     BLOCK << forwardDeclarations;
@@ -1173,8 +1174,8 @@ CodeBlock SyncedSchema::generateDependencies() const {
 
 std::string SyncedSchema::getNamespace() const {
   std::string namespaceString = "::";
-  if (codeProperties.get().globalNamespace_.has_value()) {
-    namespaceString += codeProperties.get().globalNamespace_.value() + "::";
+  if (codeProperties_.get().globalNamespace_.has_value()) {
+    namespaceString += codeProperties_.get().globalNamespace_.value() + "::";
   }
   namespaceString += identifier_;
   return namespaceString;
@@ -1274,20 +1275,26 @@ std::string SyncedSchema::getType() const {
 }
 
 std::string SyncedSchema::getNamespaceLocation() const {
-  if (codeProperties.get().globalNamespace_.has_value()) {
-    return std::format(
-        "::{}::{}", codeProperties.get().globalNamespace_.value(), identifier_);
+  if (codeProperties_.get().globalNamespace_.has_value()) {
+    return std::format("::{}::{}",
+                       codeProperties_.get().globalNamespace_.value(),
+                       identifier_);
   }
   return std::format("::{}", identifier_);
 }
 
 std::vector<std::unique_ptr<SyncedSchema>>
-SyncedSchema::resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas) {
+SyncedSchema::resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas,
+                                   const CodeProperties& codeProperties) {
   try {
     std::vector<std::unique_ptr<SyncedSchema>> syncedSchemas;
+    syncedSchemas.reserve(schemas.size());
+    auto trueSchemaPtr = getTrueSchema(codeProperties);
+    const auto& trueSchema = *trueSchemaPtr;
     for (auto& schema : schemas) {
       std::unique_ptr<SyncedSchema> syncedSchema =
-          std::make_unique<SyncedSchema>(schema.identifier_);
+          std::make_unique<SyncedSchema>(schema.identifier_, trueSchema,
+                                         codeProperties);
       syncedSchemas.emplace_back(std::move(syncedSchema));
     }
     for (size_t i = 0; i < schemas.size(); i++) {
@@ -1309,7 +1316,7 @@ SyncedSchema::resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas) {
       syncedSchema.numberProperties_ = schema.numberProperties_;
       syncedSchema.stringProperties_ = schema.stringProperties_;
       syncedSchema.arrayProperties_ =
-          ArrayProperties(schema.arrayProperties_, syncedSchemas);
+          ArrayProperties(schema.arrayProperties_, syncedSchemas, trueSchema);
       syncedSchema.objectProperties_.maxProperties_ =
           schema.objectProperties_.maxProperties_;
       syncedSchema.objectProperties_.minProperties_ =
@@ -1335,7 +1342,7 @@ SyncedSchema::resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas) {
             *syncedSchemas[schema.objectProperties_.additionalProperties_
                                .value()];
       } else {
-        syncedSchema.objectProperties_.additionalProperties_ = getTrueSchema();
+        syncedSchema.objectProperties_.additionalProperties_ = trueSchema;
       }
       syncedSchema.objectProperties_.propertyDependencies_ =
           schema.objectProperties_.propertyDependencies_;
@@ -1350,7 +1357,8 @@ SyncedSchema::resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas) {
               propertyName, *syncedSchemas[index]);
         }
       }
-      // syncedSchema.objectProperties_.propertyNames_ = schema.propertyNames_;
+      // syncedSchema.objectProperties_.propertyNames_ =
+      // schema.propertyNames_;
       if (schema.objectProperties_.propertyNames_.has_value()) {
         syncedSchema.objectProperties_.propertyNames_ =
             *syncedSchemas[schema.objectProperties_.propertyNames_.value()];
@@ -1409,7 +1417,7 @@ SyncedSchema::resolveIndexedSchema(std::vector<IndexedSyncedSchema>&& schemas) {
       syncedSchema.format_ = schema.format_;
       syncedSchema.default_ = schema.default_;
     }
-    syncedSchemas.emplace_back(std::make_unique<SyncedSchema>(getTrueSchema()));
+    syncedSchemas.emplace_back(std::move(trueSchemaPtr));
     return syncedSchemas;
   } catch (const std::exception& e) {
     std::cerr << "Error transitioning Indexed Synced to Synced: ";
@@ -1427,6 +1435,7 @@ void SyncedSchema::dumpSchemas(
     if (schema->definedAsBooleanSchema_.has_value()) {
       schemaDump["definedAsBooleanSchema"] =
           schema->definedAsBooleanSchema_.value();
+      continue;
     }
     if (schema->reinterpretables_.ref_.has_value()) {
       schemaDump["ref"] =
diff --git a/src/SyncedSchema/ArrayProperties.cpp b/src/SyncedSchema/ArrayProperties.cpp
index a7aa9fc..0e6d0e0 100644
--- a/src/SyncedSchema/ArrayProperties.cpp
+++ b/src/SyncedSchema/ArrayProperties.cpp
@@ -6,10 +6,11 @@
 
 ArrayProperties::ArrayProperties(
     const IndexedArrayProperties& arrayProperties,
-    const std::vector<std::unique_ptr<SyncedSchema>>& syncedSchemas)
+    const std::vector<std::unique_ptr<SyncedSchema>>& syncedSchemas,
+    const SyncedSchema& trueSchema)
     : items_(arrayProperties.items_.has_value()
                  ? *syncedSchemas[arrayProperties.items_.value()]
-                 : SyncedSchema::getTrueSchema()) {
+                 : trueSchema) {
   if (arrayProperties.tupleableItems_.has_value()) {
     tupleableItems_ = std::vector<std::reference_wrapper<const SyncedSchema>>();
     for (auto index : arrayProperties.tupleableItems_.value()) {
diff --git a/src/main.cpp b/src/main.cpp
index 9f5cf67..4804eb7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,3 +1,4 @@
+#include "CodeProperties.h"
 #include "Document.h"
 #include "Draft07.h"
 #include "DraftInterpreter.h"
@@ -39,6 +40,7 @@ int main(int argc, char* argv[]) {
   std::vector<std::filesystem::path> inputFiles;
   std::vector<std::string> requiredFiles;
   std::map<UriWrapper, std::string> preferredIdentifiers;
+  CodeProperties codeProperties;
   bool dumpSchemas = false;
 
   // configure extra options here
@@ -109,6 +111,39 @@ int main(int argc, char* argv[]) {
         return 1;
       }
     }
+    if (args[i] == "--namespace" || args[i] == "-n") {
+      if (i + 1 < argc) {
+        codeProperties.globalNamespace_ = args[i + 1];
+        i += 1;
+        continue;
+      } else {
+        std::cerr << "Error: --namespace requires an argument." << std::endl;
+        return 1;
+      }
+    }
+    if (args[i] == "--no-namespace" || args[i] == "-nn") {
+      codeProperties.globalNamespace_ = std::nullopt;
+      continue;
+    }
+    if (args[i] == "--define-prefix" || args[i] == "-dp") {
+      if (i + 1 < argc) {
+        codeProperties.definePrefix_ = args[i + 1];
+        i += 1;
+        continue;
+      } else {
+        std::cerr << "Error: --define-prefix requires an argument."
+                  << std::endl;
+        return 1;
+      }
+    }
+    if (args[i] == "--use-pragma" || args[i] == "-up") {
+      codeProperties.headerGuardType_ = CodeProperties::HeaderGuard::Pragma;
+      continue;
+    }
+    if (args[i] == "--use-ifndef" || args[i] == "-ui") {
+      codeProperties.headerGuardType_ = CodeProperties::HeaderGuard::Ifndef;
+      continue;
+    }
     if (args[i].starts_with('-')) {
       std::cerr << "Error: Unknown option " << args[i] << std::endl;
       return 1;
@@ -175,8 +210,8 @@ int main(int argc, char* argv[]) {
   if (dumpSchemas)
     IndexedSyncedSchema::dumpSchemas(indexedSyncedSchemas, outputDirectory);
 
-  auto syncedSchemas =
-      SyncedSchema::resolveIndexedSchema(std::move(indexedSyncedSchemas));
+  auto syncedSchemas = SyncedSchema::resolveIndexedSchema(
+      std::move(indexedSyncedSchemas), codeProperties);
 
   SyncedSchema::dumpSchemas(syncedSchemas);