diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 000000000..682eff608
Binary files /dev/null and b/.DS_Store differ
diff --git a/.gitignore b/.gitignore
index 73912aea3..cf48c5a89 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,6 @@ project/boot/
 # Unpacking complete binaries for testing purposes
 /runnable
 js/npm
+
+.bsp/
+.metals/
\ No newline at end of file
diff --git a/.idea/runConfigurations/ksc_formats_all.xml b/.idea/runConfigurations/ksc_formats_all.xml
index 2e50788c5..ef27ba060 100644
--- a/.idea/runConfigurations/ksc_formats_all.xml
+++ b/.idea/runConfigurations/ksc_formats_all.xml
@@ -1,8 +1,10 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="ksc formats all" type="Application" factoryName="Application">
+    <option name="ALTERNATIVE_JRE_PATH" value="1.8" />
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
     <option name="MAIN_CLASS_NAME" value="io.kaitai.struct.JavaMain" />
-    <module name="jvm.kaitai-struct-compiler" />
-    <option name="PROGRAM_PARAMETERS" value="--verbose all -t all --ksc-exceptions -d ../tests/compiled --java-package io.kaitai.struct.testformats --php-namespace 'Kaitai\Struct\Tests' --go-package test_formats --nim-module &quot;kaitai_struct_nim_runtime&quot; --nim-opaque &quot;../../tests/spec/nim/opaque/&quot; ../tests/formats/bcd_user_type_be.ksy ../tests/formats/bcd_user_type_le.ksy ../tests/formats/bits_byte_aligned.ksy ../tests/formats/bits_enum.ksy ../tests/formats/bits_seq_endian_combo.ksy ../tests/formats/bits_shift_by_b32_le.ksy ../tests/formats/bits_shift_by_b64_le.ksy ../tests/formats/bits_signed_res_b32_be.ksy ../tests/formats/bits_signed_res_b32_le.ksy ../tests/formats/bits_signed_shift_b32_le.ksy ../tests/formats/bits_signed_shift_b64_le.ksy ../tests/formats/bits_simple.ksy ../tests/formats/bits_simple_le.ksy ../tests/formats/bits_unaligned_b32_be.ksy ../tests/formats/bits_unaligned_b32_le.ksy ../tests/formats/bits_unaligned_b64_be.ksy ../tests/formats/bits_unaligned_b64_le.ksy ../tests/formats/buffered_struct.ksy ../tests/formats/buffered_struct_raw.ksy ../tests/formats/bytes_pad_term.ksy ../tests/formats/cast_nested.ksy ../tests/formats/cast_to_imported.ksy ../tests/formats/cast_to_top.ksy ../tests/formats/combine_bool.ksy ../tests/formats/combine_bytes.ksy ../tests/formats/combine_enum.ksy ../tests/formats/combine_str.ksy ../tests/formats/debug_0.ksy ../tests/formats/debug_array_user.ksy ../tests/formats/debug_enum_name.ksy ../tests/formats/debug_switch_user.ksy ../tests/formats/default_big_endian.ksy ../tests/formats/default_bit_endian_mod.ksy ../tests/formats/default_endian_expr_exception.ksy ../tests/formats/default_endian_expr_inherited.ksy ../tests/formats/default_endian_expr_is_be.ksy ../tests/formats/default_endian_expr_is_le.ksy ../tests/formats/default_endian_mod.ksy ../tests/formats/docstrings_docref.ksy ../tests/formats/docstrings_docref_multi.ksy ../tests/formats/docstrings.ksy ../tests/formats/enum_0.ksy ../tests/formats/enum_1.ksy ../tests/formats/enum_deep.ksy ../tests/formats/enum_deep_literals.ksy ../tests/formats/enum_fancy.ksy ../tests/formats/enum_for_unknown_id.ksy ../tests/formats/enum_if.ksy ../tests/formats/enum_import.ksy ../tests/formats/enum_int_range_s.ksy ../tests/formats/enum_int_range_u.ksy ../tests/formats/enum_invalid.ksy ../tests/formats/enum_long_range_s.ksy ../tests/formats/enum_long_range_u.ksy ../tests/formats/enum_negative.ksy ../tests/formats/enum_of_value_inst.ksy ../tests/formats/enum_to_i_class_border_1.ksy ../tests/formats/enum_to_i_class_border_2.ksy ../tests/formats/enum_to_i.ksy ../tests/formats/eof_exception_bytes.ksy ../tests/formats/eof_exception_u4.ksy ../tests/formats/eos_exception_bytes.ksy ../tests/formats/eos_exception_u4.ksy ../tests/formats/expr_0.ksy ../tests/formats/expr_1.ksy ../tests/formats/expr_2.ksy ../tests/formats/expr_3.ksy ../tests/formats/expr_array.ksy ../tests/formats/expr_bits.ksy ../tests/formats/expr_bytes_cmp.ksy ../tests/formats/expr_bytes_non_literal.ksy ../tests/formats/expr_bytes_ops.ksy ../tests/formats/expr_calc_array_ops.ksy ../tests/formats/expr_enum.ksy ../tests/formats/expr_if_int_ops.ksy ../tests/formats/expr_int_div.ksy ../tests/formats/expr_io_eof.ksy ../tests/formats/expr_io_pos.ksy ../tests/formats/expr_mod.ksy ../tests/formats/expr_ops_parens.ksy ../tests/formats/expr_sizeof_type_0.ksy ../tests/formats/expr_sizeof_type_1.ksy ../tests/formats/expr_sizeof_value_0.ksy ../tests/formats/expr_sizeof_value_sized.ksy ../tests/formats/expr_str_encodings.ksy ../tests/formats/expr_str_ops.ksy ../tests/formats/fixed_contents.ksy ../tests/formats/fixed_struct.ksy ../tests/formats/floating_points.ksy ../tests/formats/float_to_i.ksy ../tests/formats/hello_world.ksy ../tests/formats/if_instances.ksy ../tests/formats/if_struct.ksy ../tests/formats/if_values.ksy ../tests/formats/imports0.ksy ../tests/formats/imports_abs_abs.ksy ../tests/formats/imports_abs.ksy ../tests/formats/imports_abs_rel.ksy ../tests/formats/imports_circular_a.ksy ../tests/formats/imports_circular_b.ksy ../tests/formats/imports_rel_1.ksy ../tests/formats/index_sizes.ksy ../tests/formats/index_to_param_eos.ksy ../tests/formats/index_to_param_expr.ksy ../tests/formats/index_to_param_until.ksy ../tests/formats/instance_io_user.ksy ../tests/formats/instance_std_array.ksy ../tests/formats/instance_std.ksy ../tests/formats/instance_user_array.ksy ../tests/formats/integers_double_overflow.ksy ../tests/formats/integers.ksy ../tests/formats/integers_min_max.ksy ../tests/formats/io_local_var.ksy ../tests/formats/js_signed_right_shift.ksy ../tests/formats/meta_tags.ksy ../tests/formats/meta_xref.ksy ../tests/formats/multiple_use.ksy ../tests/formats/nav_parent2.ksy ../tests/formats/nav_parent3.ksy ../tests/formats/nav_parent_false2.ksy ../tests/formats/nav_parent_false.ksy ../tests/formats/nav_parent.ksy ../tests/formats/nav_parent_override.ksy ../tests/formats/nav_parent_switch_cast.ksy ../tests/formats/nav_parent_switch.ksy ../tests/formats/nav_parent_vs_value_inst.ksy ../tests/formats/nav_root.ksy ../tests/formats/nested_same_name2.ksy ../tests/formats/nested_same_name.ksy ../tests/formats/nested_type_param.ksy ../tests/formats/nested_types2.ksy ../tests/formats/nested_types3.ksy ../tests/formats/nested_types.ksy ../tests/formats/non_standard.ksy ../tests/formats/opaque_external_type_02_child.ksy ../tests/formats/opaque_external_type_02_parent.ksy ../tests/formats/opaque_external_type.ksy ../tests/formats/opaque_with_param.ksy ../tests/formats/optional_id.ksy ../tests/formats/params_call_extra_parens.ksy ../tests/formats/params_call_short.ksy ../tests/formats/params_def.ksy ../tests/formats/params_enum.ksy ../tests/formats/params_pass_array_int.ksy ../tests/formats/params_pass_array_str.ksy ../tests/formats/params_pass_array_struct.ksy ../tests/formats/params_pass_array_usertype.ksy ../tests/formats/params_pass_bool.ksy ../tests/formats/params_pass_struct.ksy ../tests/formats/params_pass_usertype.ksy ../tests/formats/position_abs.ksy ../tests/formats/position_in_seq.ksy ../tests/formats/position_to_end.ksy ../tests/formats/process_coerce_bytes.ksy ../tests/formats/process_coerce_switch.ksy ../tests/formats/process_coerce_usertype1.ksy ../tests/formats/process_coerce_usertype2.ksy ../tests/formats/process_custom.ksy ../tests/formats/process_custom_no_args.ksy ../tests/formats/process_repeat_bytes.ksy ../tests/formats/process_repeat_usertype.ksy ../tests/formats/process_rotate.ksy ../tests/formats/process_to_user.ksy ../tests/formats/process_xor4_const.ksy ../tests/formats/process_xor4_value.ksy ../tests/formats/process_xor_const.ksy ../tests/formats/process_xor_value.ksy ../tests/formats/recursive_one.ksy ../tests/formats/repeat_eos_bit.ksy ../tests/formats/repeat_eos_struct.ksy ../tests/formats/repeat_eos_u4.ksy ../tests/formats/repeat_n_struct.ksy ../tests/formats/repeat_n_strz_double.ksy ../tests/formats/repeat_n_strz.ksy ../tests/formats/repeat_until_calc_array_type.ksy ../tests/formats/repeat_until_complex.ksy ../tests/formats/repeat_until_s4.ksy ../tests/formats/repeat_until_sized.ksy ../tests/formats/str_encodings_default.ksy ../tests/formats/str_encodings.ksy ../tests/formats/str_encodings_utf16.ksy ../tests/formats/str_eos.ksy ../tests/formats/str_literals2.ksy ../tests/formats/str_literals.ksy ../tests/formats/str_pad_term_empty.ksy ../tests/formats/str_pad_term.ksy ../tests/formats/switch_bytearray.ksy ../tests/formats/switch_cast.ksy ../tests/formats/switch_else_only.ksy ../tests/formats/switch_integers2.ksy ../tests/formats/switch_integers.ksy ../tests/formats/switch_manual_enum_invalid_else.ksy ../tests/formats/switch_manual_enum_invalid.ksy ../tests/formats/switch_manual_enum.ksy ../tests/formats/switch_manual_int_else.ksy ../tests/formats/switch_manual_int.ksy ../tests/formats/switch_manual_int_size_else.ksy ../tests/formats/switch_manual_int_size_eos.ksy ../tests/formats/switch_manual_int_size.ksy ../tests/formats/switch_manual_str_else.ksy ../tests/formats/switch_manual_str.ksy ../tests/formats/switch_multi_bool_ops.ksy ../tests/formats/switch_repeat_expr_invalid.ksy ../tests/formats/switch_repeat_expr.ksy ../tests/formats/term_bytes.ksy ../tests/formats/term_strz.ksy ../tests/formats/term_u1_val.ksy ../tests/formats/to_string_custom.ksy ../tests/formats/ts_packet_header.ksy ../tests/formats/type_int_unary_op.ksy ../tests/formats/type_ternary_2nd_falsy.ksy ../tests/formats/type_ternary.ksy ../tests/formats/type_ternary_opaque.ksy ../tests/formats/user_type.ksy ../tests/formats/valid_eq_str_encodings.ksy ../tests/formats/valid_fail_anyof_int.ksy ../tests/formats/valid_fail_contents.ksy ../tests/formats/valid_fail_eq_bytes.ksy ../tests/formats/valid_fail_eq_int.ksy ../tests/formats/valid_fail_eq_str.ksy ../tests/formats/valid_fail_expr.ksy ../tests/formats/valid_fail_inst.ksy ../tests/formats/valid_fail_max_int.ksy ../tests/formats/valid_fail_min_int.ksy ../tests/formats/valid_fail_range_bytes.ksy ../tests/formats/valid_fail_range_float.ksy ../tests/formats/valid_fail_range_int.ksy ../tests/formats/valid_fail_range_str.ksy ../tests/formats/valid_long.ksy ../tests/formats/valid_not_parsed_if.ksy ../tests/formats/valid_optional_id.ksy ../tests/formats/valid_short.ksy ../tests/formats/valid_switch.ksy ../tests/formats/yaml_ints.ksy ../tests/formats/zlib_surrounded.ksy ../tests/formats/zlib_with_header_78.ksy" />
+    <module name="root.kaitai-struct-compiler" />
+    <option name="PROGRAM_PARAMETERS" value="--verbose all -t go --ksc-exceptions -d ../tests/compiled --java-package io.kaitai.struct.testformats --php-namespace 'Kaitai\Struct\Tests' --go-package test_formats --nim-module &quot;kaitai_struct_nim_runtime&quot; --nim-opaque &quot;../../tests/spec/nim/opaque/&quot; --read-write /tmp/test.ksy" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="io.kaitai.struct.*" />
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 000000000..32cfc61d2
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+    "files.watcherExclude": {
+        "**/target": true
+    }
+}
\ No newline at end of file
diff --git a/jvm/src/main/scala/io/kaitai/struct/JavaMain.scala b/jvm/src/main/scala/io/kaitai/struct/JavaMain.scala
index 2e0c6b57a..52b725665 100644
--- a/jvm/src/main/scala/io/kaitai/struct/JavaMain.scala
+++ b/jvm/src/main/scala/io/kaitai/struct/JavaMain.scala
@@ -11,6 +11,8 @@ import io.kaitai.struct.languages.CppCompiler
 import io.kaitai.struct.languages.components.LanguageCompilerStatic
 import io.kaitai.struct.problems.{CompilationProblem, CompilationProblemException, ErrorInInput}
 
+import scala.collection.immutable.Map
+
 object JavaMain {
   KSVersion.current = Version.version
 
@@ -57,6 +59,10 @@ object JavaMain {
         }
       }
 
+      opt[Unit]('w', "read-write") action { (x, c) =>
+        c.copy(runtime = c.runtime.copy(readWrite = true, autoRead = false))
+      } text("generate read-write support in classes (implies `--no-auto-read --zero-copy-substream false`, Java and Python only, default: read-only)")
+
       opt[File]('d', "outdir") valueName("<directory>") action { (x, c) =>
         c.copy(outDir = x)
       } text("output directory (filenames will be auto-generated); on Unix-like shells, the short form `-d` requires arguments to be preceded by `--`")
@@ -172,7 +178,13 @@ object JavaMain {
       version("version") text("output version information and exit")
     }
 
-    parser.parse(args, CLIConfig())
+    parser.parse(args, CLIConfig()).map { c =>
+      if (c.runtime.readWrite) {
+        c.copy(runtime = c.runtime.copy(zeroCopySubstream = false))
+      } else {
+        c
+      }
+    }
   }
 
   /**
@@ -259,8 +271,8 @@ class JavaMain(config: CLIConfig) {
   def run(): Unit = {
     val logs: Map[String, InputEntry] = config.srcFiles.map { srcFile =>
       val log = if (config.throwExceptions) {
-        compileOneInput(srcFile)
-      } else {
+        compileOneInput(srcFile)      } else {
+
         try {
           compileOneInput(srcFile)
         } catch {
@@ -292,26 +304,55 @@ class JavaMain(config: CLIConfig) {
 
   private def compileOneInput(srcFile: String): InputEntry = {
     Log.fileOps.info(() => s"parsing $srcFile...")
-    val (specsOpt, precompileProblems) = JavaKSYParser.localFileToSpecs(srcFile, config)
-
-    specsOpt match {
-      case Some(specs) =>
-        val output: Map[String, Map[String, SpecEntry]] = config.targets match {
-          case Seq(lang) =>
-            // single target, just use target directory as is
-            val out = compileOneLang(specs, lang, config.outDir.toString)
-            Map(lang -> out)
-          case _ =>
-            // multiple targets, use additional directories
-            compileAllLangs(specs, config)
+
+    val dir = new File(srcFile)
+
+    if ( dir.isDirectory ) {
+      var recordInput: InputSuccess = null
+      for ( f: File <- dir.listFiles() ) {
+        val (specsOpt, precompileProblems) = JavaKSYParser.localFileToSpecs(f.getPath, config)
+        specsOpt match {
+          case Some(specs) =>
+            val output: Map[String, Map[String, SpecEntry]] = config.targets match {
+              case Seq(lang) =>
+                // single target, just use target directory as is
+                val out = compileOneLang(specs, lang, config.outDir.toString)
+                Map(lang -> out)
+              case _ =>
+                // multiple targets, use additional directories
+                compileAllLangs(specs, config)
+            }
+            recordInput = InputSuccess(
+              specs.firstSpec.nameAsStr,
+              output,
+              precompileProblems
+            )
+          case None =>
+            InputFailure(precompileProblems)
         }
-        InputSuccess(
-          specs.firstSpec.nameAsStr,
-          output,
-          precompileProblems
-        )
-      case None =>
-        InputFailure(precompileProblems)
+      }
+      recordInput
+    } else {
+      val (specsOpt, precompileProblems) = JavaKSYParser.localFileToSpecs(srcFile, config)
+      specsOpt match {
+        case Some(specs) =>
+          val output: Map[String, Map[String, SpecEntry]] = config.targets match {
+            case Seq(lang) =>
+              // single target, just use target directory as is
+              val out = compileOneLang(specs, lang, config.outDir.toString)
+              Map(lang -> out)
+            case _ =>
+              // multiple targets, use additional directories
+              compileAllLangs(specs, config)
+          }
+          InputSuccess(
+            specs.firstSpec.nameAsStr,
+            output,
+            precompileProblems
+          )
+        case None =>
+          InputFailure(precompileProblems)
+      }
     }
   }
 
diff --git a/jvm/src/test/scala/io/kaitai/struct/translators/TranslatorSpec.scala b/jvm/src/test/scala/io/kaitai/struct/translators/TranslatorSpec.scala
index 31f254507..a63d01687 100644
--- a/jvm/src/test/scala/io/kaitai/struct/translators/TranslatorSpec.scala
+++ b/jvm/src/test/scala/io/kaitai/struct/translators/TranslatorSpec.scala
@@ -692,8 +692,8 @@ class TranslatorSpec extends AnyFunSuite {
     val langs = Map[LanguageCompilerStatic, AbstractTranslator with TypeDetector](
       CppCompiler -> new CppTranslator(tp, new CppImportList(), new CppImportList(), RuntimeConfig()),
       CSharpCompiler -> new CSharpTranslator(tp, new ImportList()),
-      GoCompiler -> new GoTranslator(goOutput, tp, new ImportList()),
-      JavaCompiler -> new JavaTranslator(tp, new ImportList()),
+      GoCompiler -> new GoTranslator(goOutput, tp, new ImportList(), RuntimeConfig()),
+      JavaCompiler -> new JavaTranslator(tp, new ImportList(), RuntimeConfig()),
       JavaScriptCompiler -> new JavaScriptTranslator(tp),
       LuaCompiler -> new LuaTranslator(tp, new ImportList()),
       PerlCompiler -> new PerlTranslator(tp, new ImportList()),
diff --git a/project/.bloop/bloop.settings.json b/project/.bloop/bloop.settings.json
new file mode 100644
index 000000000..e44a8e400
--- /dev/null
+++ b/project/.bloop/bloop.settings.json
@@ -0,0 +1,23 @@
+{
+    "javaSemanticDBVersion": "0.9.6",
+    "semanticDBVersion": "4.8.12",
+    "supportedScalaVersions": [
+        "2.13.12",
+        "2.12.18",
+        "2.12.17",
+        "2.12.16",
+        "2.12.15",
+        "2.13.9",
+        "2.13.10",
+        "2.13.11",
+        "2.11.12",
+        "2.12.11",
+        "2.12.12",
+        "2.12.13",
+        "2.12.14",
+        "2.13.5",
+        "2.13.6",
+        "2.13.7",
+        "2.13.8"
+    ]
+}
\ No newline at end of file
diff --git a/project/project/.bloop/bloop.settings.json b/project/project/.bloop/bloop.settings.json
new file mode 100644
index 000000000..e44a8e400
--- /dev/null
+++ b/project/project/.bloop/bloop.settings.json
@@ -0,0 +1,23 @@
+{
+    "javaSemanticDBVersion": "0.9.6",
+    "semanticDBVersion": "4.8.12",
+    "supportedScalaVersions": [
+        "2.13.12",
+        "2.12.18",
+        "2.12.17",
+        "2.12.16",
+        "2.12.15",
+        "2.13.9",
+        "2.13.10",
+        "2.13.11",
+        "2.11.12",
+        "2.12.11",
+        "2.12.12",
+        "2.12.13",
+        "2.12.14",
+        "2.13.5",
+        "2.13.6",
+        "2.13.7",
+        "2.13.8"
+    ]
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/io/kaitai/struct/ClassCompiler.scala b/shared/src/main/scala/io/kaitai/struct/ClassCompiler.scala
index f7aa87f56..20dd13450 100644
--- a/shared/src/main/scala/io/kaitai/struct/ClassCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/ClassCompiler.scala
@@ -6,6 +6,7 @@ import io.kaitai.struct.datatype._
 import io.kaitai.struct.exprlang.Ast
 import io.kaitai.struct.format.{AttrSpec, _}
 import io.kaitai.struct.languages.components.{ExtraAttrs, LanguageCompiler, LanguageCompilerStatic}
+import io.kaitai.struct.translators.GoTranslator
 
 class ClassCompiler(
   classSpecs: ClassSpecs,
@@ -78,6 +79,15 @@ class ClassCompiler(
     // Read method(s)
     compileEagerRead(curClass.seq, curClass.meta.endian)
 
+    compileFetchInstancesProc(curClass.seq ++ curClass.instances.values.collect {
+      case inst: AttrLikeSpec => inst
+    })
+
+    if (config.readWrite) {
+      compileEagerWrite(curClass.seq, curClass.instances, curClass.meta.endian)
+      compileCheck(curClass.seq)
+    }
+
     // Destructor
     compileDestructor(curClass)
 
@@ -132,6 +142,15 @@ class ClassCompiler(
     )
     compileInit(curClass)
     curClass.instances.foreach { case (instName, _) => lang.instanceClear(instName) }
+    if (config.readWrite) {
+      curClass.instances.foreach { case (instName, instSpec) =>
+        instSpec match {
+          case _: ParseInstanceSpec =>
+            lang.instanceWriteFlagInit(instName)
+          case _: ValueInstanceSpec => // do nothing
+        }
+      }
+    }
     if (lang.config.autoRead)
       lang.runRead(curClass.name)
     lang.classConstructorFooter
@@ -217,6 +236,9 @@ class ClassCompiler(
         attr.isNullable
       }
       lang.attributeReader(attr.id, attr.dataTypeComposite, isNullable)
+      if (config.readWrite) {
+        lang.attributeSetter(attr.id, attr.dataTypeComposite, isNullable)
+      }
     }
   }
 
@@ -236,25 +258,53 @@ class ClassCompiler(
   def compileEagerRead(seq: List[AttrSpec], endian: Option[Endianness]): Unit = {
     endian match {
       case None | Some(_: FixedEndian) =>
-        compileSeqProc(seq, None)
+        compileSeqReadProc(seq, None)
       case Some(ce: CalcEndian) =>
         lang.readHeader(None, false)
         compileCalcEndian(ce)
         lang.runReadCalc()
         lang.readFooter()
 
-        compileSeqProc(seq, Some(LittleEndian))
-        compileSeqProc(seq, Some(BigEndian))
+        compileSeqReadProc(seq, Some(LittleEndian))
+        compileSeqReadProc(seq, Some(BigEndian))
       case Some(InheritedEndian) =>
         lang.readHeader(None, false)
         lang.runReadCalc()
         lang.readFooter()
 
-        compileSeqProc(seq, Some(LittleEndian))
-        compileSeqProc(seq, Some(BigEndian))
+        compileSeqReadProc(seq, Some(LittleEndian))
+        compileSeqReadProc(seq, Some(BigEndian))
+    }
+  }
+
+  def compileEagerWrite(seq: List[AttrSpec], instances: Map[InstanceIdentifier, InstanceSpec], endian: Option[Endianness]): Unit = {
+    endian match {
+      case None | Some(_: FixedEndian) =>
+        compileSeqWriteProc(seq, instances, None)
+      case Some(ce: CalcEndian) =>
+        lang.writeHeader(None, false)
+        compileCalcEndian(ce)
+        lang.runWriteCalc()
+        lang.writeFooter()
+
+        compileSeqWriteProc(seq, instances, Some(LittleEndian))
+        compileSeqWriteProc(seq, instances, Some(BigEndian))
+      case Some(InheritedEndian) =>
+        lang.writeHeader(None, false)
+        lang.runWriteCalc()
+        lang.writeFooter()
+
+        compileSeqWriteProc(seq, instances, Some(LittleEndian))
+        compileSeqWriteProc(seq, instances, Some(BigEndian))
     }
   }
 
+  def compileCheck(seq: List[AttrSpec]): Unit = {
+    lang.checkHeader()
+    compileSeqCheck(seq)
+    lang.checkFooter()
+  }
+
   val IS_LE_ID = SpecialIdentifier("_is_le")
 
   /**
@@ -276,18 +326,31 @@ class ClassCompiler(
     * @param seq sequence of attributes
     * @param defEndian default endianness
     */
-  def compileSeqProc(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
+  def compileSeqReadProc(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
     lang.readHeader(defEndian, seq.isEmpty)
-    compileSeq(seq, defEndian)
+    compileSeqRead(seq, defEndian)
     lang.readFooter()
   }
 
+  def compileFetchInstancesProc(attrs: List[AttrLikeSpec]) = {
+    lang.fetchInstancesHeader()
+    compileFetchInstances(attrs)
+    lang.fetchInstancesFooter()
+  }
+
+  def compileSeqWriteProc(seq: List[AttrSpec], instances: Map[InstanceIdentifier, InstanceSpec], defEndian: Option[FixedEndian]) = {
+    lang.writeHeader(defEndian, !instances.values.exists(i => i.isInstanceOf[ParseInstanceSpec]) && seq.isEmpty)
+    compileSetInstanceWriteFlags(instances)
+    compileSeqWrite(seq, defEndian)
+    lang.writeFooter()
+  }
+
   /**
     * Compiles seq reading method body (only reading statements).
     * @param seq sequence of attributes
     * @param defEndian default endianness
     */
-  def compileSeq(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
+  def compileSeqRead(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
     var wasUnaligned = false
     seq.foreach { (attr) =>
       val nowUnaligned = isUnalignedBits(attr.dataType)
@@ -298,6 +361,34 @@ class ClassCompiler(
     }
   }
 
+  def compileFetchInstances(attrs: List[AttrLikeSpec]): Unit = {
+    attrs.foreach { (attr) =>
+      lang.attrFetchInstances(attr, attr.id)
+    }
+  }
+
+  def compileSetInstanceWriteFlags(instances: Map[InstanceIdentifier, InstanceSpec]) = {
+    instances.foreach { case (instName, instSpec) =>
+      instSpec match {
+        case _: ParseInstanceSpec =>
+          lang.instanceSetWriteFlag(instName)
+        case _: ValueInstanceSpec => // do nothing
+      }
+    }
+  }
+
+  def compileSeqWrite(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
+    seq.foreach { (attr) =>
+      lang.attrWrite(attr, attr.id, defEndian)
+    }
+  }
+
+  def compileSeqCheck(seq: List[AttrSpec]) = {
+    seq.foreach { (attr) =>
+      lang.attrCheck(attr, attr.id)
+    }
+  }
+
   /**
     * Compiles all enums specifications for a given type.
     * @param curClass current type to generate code for
@@ -329,6 +420,12 @@ class ClassCompiler(
     lang.instanceHeader(className, instName, dataType, instSpec.isNullable)
     if (lang.innerDocstrings)
       compileInstanceDoc(instName, instSpec)
+    if (config.readWrite)
+      instSpec match {
+        case _: ParseInstanceSpec =>
+          lang.instanceCheckWriteFlagAndWrite(instName)
+        case _: ValueInstanceSpec => // do nothing
+      }
     lang.instanceCheckCacheAndReturn(instName, dataType)
 
     instSpec match {
@@ -343,6 +440,22 @@ class ClassCompiler(
 
     lang.instanceReturn(instName, dataType)
     lang.instanceFooter
+
+    if (config.readWrite)
+      instSpec match {
+        case pi: ParseInstanceSpec =>
+          lang.attributeSetter(instName, dataType, instSpec.isNullable)
+          lang.instanceToWriteSetter(instName)
+          lang.writeInstanceHeader(instName)
+          lang.attrWrite(pi, instName, endian)
+          lang.writeInstanceFooter
+
+          lang.checkInstanceHeader(instName)
+          lang.attrCheck(pi, instName)
+          lang.checkInstanceFooter
+        case _: ValueInstanceSpec =>
+          lang.instanceInvalidate(instName)
+      }
   }
 
   def compileInstanceDeclaration(instName: InstanceIdentifier, instSpec: InstanceSpec): Unit = {
@@ -355,10 +468,21 @@ class ClassCompiler(
       instSpec.isNullable
     }
     lang.instanceDeclaration(instName, instSpec.dataTypeComposite, isNullable)
+    if (config.readWrite)
+      instSpec match {
+        case _: ParseInstanceSpec =>
+          lang.instanceWriteFlagDeclaration(instName)
+        case _: ValueInstanceSpec => // do nothing
+      }
   }
 
-  def compileEnum(curClass: ClassSpec, enumColl: EnumSpec): Unit =
-    lang.enumDeclaration(curClass.name, enumColl.name.last, enumColl.sortedSeq)
+  def compileEnum(curClass: ClassSpec, enumColl: EnumSpec): Unit = {
+    var enumName = enumColl.name.last
+    if (lang.translator.isInstanceOf[GoTranslator] && enumColl.enumType != null) {
+      enumName = s"${enumName}_insplit_${enumColl.enumType.toString()}"
+    }
+    lang.enumDeclaration(curClass.name, enumName, enumColl.sortedSeq)
+  }
 
   def isUnalignedBits(dt: DataType): Boolean =
     dt match {
diff --git a/shared/src/main/scala/io/kaitai/struct/ClassTypeProvider.scala b/shared/src/main/scala/io/kaitai/struct/ClassTypeProvider.scala
index abed472ff..c376c985e 100644
--- a/shared/src/main/scala/io/kaitai/struct/ClassTypeProvider.scala
+++ b/shared/src/main/scala/io/kaitai/struct/ClassTypeProvider.scala
@@ -57,6 +57,33 @@ class ClassTypeProvider(classSpecs: ClassSpecs, var topClass: ClassSpec) extends
       case NamedIdentifier(name) => return determineType(inClass, name)
       case InstanceIdentifier(name) => return determineType(inClass, name)
       case SpecialIdentifier(name) => return determineType(inClass, name)
+      case RawIdentifier(innerId) => {
+        val innerType = determineType(innerId)
+        val (isArray, itemType: DataType) = innerType match {
+          case at: ArrayType => (true, at.elType)
+          case t => (false, t)
+        }
+        val singleType: DataType = itemType match {
+          case st: SwitchType => st.cases.collectFirst {
+            case (_, caseType)
+              if caseType.isInstanceOf[BytesType]
+              || caseType.isInstanceOf[UserTypeFromBytes] => caseType
+          }.get
+          case t => t
+        }
+        /** see [[languages.components.ExtraAttrs$]] for possible types */
+        val bytesType = singleType match {
+          case bt: BytesType => bt
+          case utb: UserTypeFromBytes => utb.bytes
+        }
+        return if (isArray) ArrayTypeInStream(bytesType) else bytesType
+      }
+      case OuterSizeIdentifier(innerId) =>
+        val singleType = CalcIntType
+        return if (determineType(innerId).isInstanceOf[ArrayType]) ArrayTypeInStream(singleType) else singleType
+      case InnerSizeIdentifier(innerId) =>
+        val singleType = CalcIntType
+        return if (determineType(innerId).isInstanceOf[ArrayType]) ArrayTypeInStream(singleType) else singleType
       case _ => // do nothing
     }
     throw new FieldNotFoundError(attrId.humanReadable, inClass)
diff --git a/shared/src/main/scala/io/kaitai/struct/DocClassCompiler.scala b/shared/src/main/scala/io/kaitai/struct/DocClassCompiler.scala
index 685cd1c38..339a6c20b 100644
--- a/shared/src/main/scala/io/kaitai/struct/DocClassCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/DocClassCompiler.scala
@@ -37,7 +37,7 @@ abstract class DocClassCompiler(classSpecs: ClassSpecs, topClass: ClassSpec) ext
     classHeader(curClass)
 
     // Sequence
-    compileSeq(curClass)
+    compileSeqRead(curClass)
 
     // Instances
     curClass.instances.foreach { case (_, instSpec) =>
@@ -58,7 +58,7 @@ abstract class DocClassCompiler(classSpecs: ClassSpecs, topClass: ClassSpec) ext
     classFooter(curClass)
   }
 
-  def compileSeq(curClass: ClassSpec): Unit = {
+  def compileSeqRead(curClass: ClassSpec): Unit = {
     seqHeader(curClass)
 
     CalculateSeqSizes.forEachSeqAttr(curClass, (attr, seqPos, sizeElement, sizeContainer) => {
diff --git a/shared/src/main/scala/io/kaitai/struct/GoClassCompiler.scala b/shared/src/main/scala/io/kaitai/struct/GoClassCompiler.scala
index dd02b2997..c464648bb 100644
--- a/shared/src/main/scala/io/kaitai/struct/GoClassCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/GoClassCompiler.scala
@@ -1,11 +1,12 @@
 package io.kaitai.struct
 
-import io.kaitai.struct.datatype.DataType.{CalcIntType, KaitaiStreamType, UserTypeInstream}
+import io.kaitai.struct.datatype.DataType.{CalcIntType, KaitaiStreamType, UserType, UserTypeInstream}
 import io.kaitai.struct.datatype.{BigEndian, CalcEndian, Endianness, FixedEndian, InheritedEndian, LittleEndian}
 import io.kaitai.struct.exprlang.Ast
 import io.kaitai.struct.format._
 import io.kaitai.struct.languages.GoCompiler
 import io.kaitai.struct.languages.components.ExtraAttrs
+import io.kaitai.struct.translators.GoTranslator
 
 class GoClassCompiler(
   classSpecs: ClassSpecs,
@@ -16,10 +17,19 @@ class GoClassCompiler(
   override def compileClass(curClass: ClassSpec): Unit = {
     provider.nowClass = curClass
 
+    compileFetchInstancesProc(curClass.seq ++ curClass.instances.values.collect {
+      case inst: AttrLikeSpec => inst
+    })
+
+    if (config.readWrite) {
+      compileEagerWrite(curClass.seq, curClass.instances, curClass.meta.endian)
+      compileCheck(curClass.seq)
+    }
+
     val extraAttrs = List(
       AttrSpec(List(), IoIdentifier, KaitaiStreamType),
       AttrSpec(List(), RootIdentifier, UserTypeInstream(topClassName, None)),
-      AttrSpec(List(), ParentIdentifier, curClass.parentType)
+      AttrSpec(List(), ParentIdentifier, curClass.parentType),
     ) ++ ExtraAttrs.forClassSpec(curClass, lang)
 
     if (!curClass.doc.isEmpty)
@@ -30,6 +40,11 @@ class GoClassCompiler(
 
     // Basic struct declaration
     lang.classHeader(curClass.name)
+
+    if (config.readWrite) {
+      lang.classExtendMarks(List("kaitai.Stream"))
+    }
+
     compileAttrDeclarations(curClass.seq ++ curClass.params ++ extraAttrs)
     curClass.instances.foreach { case (instName, instSpec) =>
       compileInstanceDeclaration(instName, instSpec)
@@ -67,7 +82,14 @@ class GoClassCompiler(
 
     if (!instSpec.doc.isEmpty)
       lang.attributeDoc(instName, instSpec.doc)
+    lang.instanceSetter(className, instName, dataType)
     lang.instanceHeader(className, instName, dataType, instSpec.isNullable)
+    if (config.readWrite)
+      instSpec match {
+        case _: ParseInstanceSpec =>
+          lang.instanceCheckWriteFlagAndWrite(instName)
+        case _: ValueInstanceSpec => // do nothing
+      }
     lang.instanceCheckCacheAndReturn(instName, dataType)
 
     instSpec match {
@@ -82,6 +104,26 @@ class GoClassCompiler(
     lang.instanceSetCalculated(instName)
     lang.instanceReturn(instName, dataType)
     lang.instanceFooter
+
+    if (config.readWrite)
+      instSpec match {
+        case pi: ParseInstanceSpec =>
+          lang.attributeSetter(instName, dataType, instSpec.isNullable)
+          lang.instanceToWriteSetter(instName)
+          lang.writeInstanceHeader(instName)
+          lang.attrWrite(pi, instName, endian)
+          lang.writeInstanceFooter
+
+          lang.checkInstanceHeader(instName)
+          lang.attrCheck(pi, instName)
+          lang.checkInstanceFooter
+        case _: ValueInstanceSpec =>
+          var newInst = instName
+          if (lang.translator.isInstanceOf[GoTranslator]) {
+            newInst = InstanceIdentifier(instName.name.concat(s"_insplit_${dataType.toString.split('(')(0).toLowerCase()}"))
+          }
+          lang.instanceInvalidate(newInst)
+      }
   }
 
   override def compileCalcEndian(ce: CalcEndian): Unit = {
diff --git a/shared/src/main/scala/io/kaitai/struct/GraphvizClassCompiler.scala b/shared/src/main/scala/io/kaitai/struct/GraphvizClassCompiler.scala
index b41a45023..0a59a83fa 100644
--- a/shared/src/main/scala/io/kaitai/struct/GraphvizClassCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/GraphvizClassCompiler.scala
@@ -59,7 +59,7 @@ class GraphvizClassCompiler(classSpecs: ClassSpecs, topClass: ClassSpec) extends
     out.puts
 
     // Sequence
-    compileSeq(className, curClass)
+    compileSeqRead(className, curClass)
 
     curClass.instances.foreach { case (instName, instSpec) =>
       instSpec match {
@@ -84,7 +84,7 @@ class GraphvizClassCompiler(classSpecs: ClassSpecs, topClass: ClassSpec) extends
     out.puts("}")
   }
 
-  def compileSeq(className: List[String], curClass: ClassSpec): Unit = {
+  def compileSeqRead(className: List[String], curClass: ClassSpec): Unit = {
     tableStart(className, "seq")
 
     CalculateSeqSizes.forEachSeqAttr(curClass, (attr, seqPos, _, _) => {
diff --git a/shared/src/main/scala/io/kaitai/struct/NimClassCompiler.scala b/shared/src/main/scala/io/kaitai/struct/NimClassCompiler.scala
index a3f308dfc..b9d9091fb 100644
--- a/shared/src/main/scala/io/kaitai/struct/NimClassCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/NimClassCompiler.scala
@@ -51,17 +51,17 @@ class NimClassCompiler(
   override def compileEagerRead(seq: List[AttrSpec], endian: Option[Endianness]): Unit = {
     endian match {
       case None | Some(_: FixedEndian) =>
-        compileSeqProc(seq, None)
+        compileSeqReadProc(seq, None)
       case Some(ce: CalcEndian) =>
-        compileSeqProc(seq, Some(LittleEndian))
-        compileSeqProc(seq, Some(BigEndian))
+        compileSeqReadProc(seq, Some(LittleEndian))
+        compileSeqReadProc(seq, Some(BigEndian))
         lang.readHeader(None, false)
         compileCalcEndian(ce)
         lang.runReadCalc()
         lang.readFooter()
       case Some(InheritedEndian) =>
-        compileSeqProc(seq, Some(LittleEndian))
-        compileSeqProc(seq, Some(BigEndian))
+        compileSeqReadProc(seq, Some(LittleEndian))
+        compileSeqReadProc(seq, Some(BigEndian))
         lang.readHeader(None, false)
         lang.runReadCalc()
         lang.readFooter()
@@ -69,7 +69,7 @@ class NimClassCompiler(
   }
 
   // Must override just to add attribute docstrings
-  override def compileSeq(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
+  override def compileSeqRead(seq: List[AttrSpec], defEndian: Option[FixedEndian]) = {
     var wasUnaligned = false
     seq.foreach { (attr) =>
       val nowUnaligned = isUnalignedBits(attr.dataType)
@@ -153,7 +153,7 @@ class NimClassCompiler(
   def compileTypesRec(curClass: ClassSpec): Unit = {
     curClass.types.foreach { case (_, subClass) => compileTypes(subClass) }
   }
-  
+
 //  def compileEnumConstants(curClass: ClassSpec): Unit = {
 //    provider.nowClass = curClass
 //    curClass.enums.foreach { case(_, enumColl) => {
@@ -203,4 +203,3 @@ class NimClassCompiler(
   }
 
 }
-
diff --git a/shared/src/main/scala/io/kaitai/struct/RuntimeConfig.scala b/shared/src/main/scala/io/kaitai/struct/RuntimeConfig.scala
index e31d44b3a..653692b50 100644
--- a/shared/src/main/scala/io/kaitai/struct/RuntimeConfig.scala
+++ b/shared/src/main/scala/io/kaitai/struct/RuntimeConfig.scala
@@ -99,6 +99,7 @@ case class RuntimeConfig(
   readStoresPos: Boolean = false,
   opaqueTypes: Boolean = false,
   zeroCopySubstream: Boolean = true,
+  readWrite: Boolean = false,
   cppConfig: CppRuntimeConfig = CppRuntimeConfig(),
   goPackage: String = "",
   java: JavaRuntimeConfig = JavaRuntimeConfig(),
diff --git a/shared/src/main/scala/io/kaitai/struct/RustClassCompiler.scala b/shared/src/main/scala/io/kaitai/struct/RustClassCompiler.scala
index a148abc43..8deaedc7f 100644
--- a/shared/src/main/scala/io/kaitai/struct/RustClassCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/RustClassCompiler.scala
@@ -66,7 +66,7 @@ class RustClassCompiler(
     
     lang.readHeader(defEndian, false)
     
-    compileSeq(curClass.seq, defEndian)
+    compileSeqRead(curClass.seq, defEndian)
     lang.classConstructorFooter
   }
 
diff --git a/shared/src/main/scala/io/kaitai/struct/datatype/DataType.scala b/shared/src/main/scala/io/kaitai/struct/datatype/DataType.scala
index a8f5bbb88..a8f4e9803 100644
--- a/shared/src/main/scala/io/kaitai/struct/datatype/DataType.scala
+++ b/shared/src/main/scala/io/kaitai/struct/datatype/DataType.scala
@@ -148,6 +148,7 @@ object DataType {
       val cs = classSpec.get
       cs.isTopLevel || cs.meta.isOpaque
     }
+
   }
   case class UserTypeInstream(
     _name: List[String],
@@ -206,7 +207,10 @@ object DataType {
 
   val USER_TYPE_NO_PARENT = Ast.expr.Bool(false)
 
+  // 2024/1/10 change: why add calc any type here
   case object AnyType extends DataType
+  case object CalcAnyType extends DataType
+
   case object KaitaiStructType extends StructType {
     def isOwning = true
     override def asNonOwning(isOwningInExpr: Boolean = false): DataType = CalcKaitaiStructType(isOwningInExpr)
diff --git a/shared/src/main/scala/io/kaitai/struct/format/ClassSpec.scala b/shared/src/main/scala/io/kaitai/struct/format/ClassSpec.scala
index cc4fbc831..eb9231064 100644
--- a/shared/src/main/scala/io/kaitai/struct/format/ClassSpec.scala
+++ b/shared/src/main/scala/io/kaitai/struct/format/ClassSpec.scala
@@ -21,6 +21,10 @@ case object GenericStructClassSpec extends ClassSpecLike {
   override def toDataType: DataType = CalcKaitaiStructType()
 }
 
+case object MultiParentClassSpec extends ClassSpecLike {
+  override def toDataType: DataType = AnyType
+}
+
 sealed trait Sized
 case object DynamicSized extends Sized
 case object NotCalculatedSized extends Sized
diff --git a/shared/src/main/scala/io/kaitai/struct/format/EnumSpec.scala b/shared/src/main/scala/io/kaitai/struct/format/EnumSpec.scala
index d41b77b43..4d206a0cd 100644
--- a/shared/src/main/scala/io/kaitai/struct/format/EnumSpec.scala
+++ b/shared/src/main/scala/io/kaitai/struct/format/EnumSpec.scala
@@ -1,12 +1,13 @@
 package io.kaitai.struct.format
 
+import io.kaitai.struct.datatype.DataType
 import io.kaitai.struct.problems.KSYParseError
 
 import scala.collection.mutable
 
 case class EnumSpec(path: List[String], map: Map[Long, EnumValueSpec]) extends YAMLPath {
   var name = List[String]()
-
+  var enumType: DataType = null
   /**
     * @return Absolute name of enum as string, components separated by
     *         double colon operator `::`
diff --git a/shared/src/main/scala/io/kaitai/struct/format/Identifier.scala b/shared/src/main/scala/io/kaitai/struct/format/Identifier.scala
index 02b89f9c7..89957a958 100644
--- a/shared/src/main/scala/io/kaitai/struct/format/Identifier.scala
+++ b/shared/src/main/scala/io/kaitai/struct/format/Identifier.scala
@@ -20,7 +20,7 @@ abstract class Identifier {
   */
 case class NumberedIdentifier(idx: Int) extends Identifier {
   import NumberedIdentifier._
-  override def humanReadable: String = s"${TEMPLATE}_$idx"
+  override def humanReadable: String = s"_${TEMPLATE}$idx"
 }
 
 object NumberedIdentifier {
@@ -90,6 +90,14 @@ case class IoStorageIdentifier(innerId: Identifier) extends Identifier {
   override def humanReadable: String = s"io(${innerId.humanReadable})"
 }
 
+case class OuterSizeIdentifier(innerId: Identifier) extends Identifier {
+  override def humanReadable: String = s"outerSize(${innerId.humanReadable})"
+}
+
+case class InnerSizeIdentifier(innerId: Identifier) extends Identifier {
+  override def humanReadable: String = s"innerSize(${innerId.humanReadable})"
+}
+
 case class InstanceIdentifier(name: String) extends Identifier {
   Identifier.checkIdentifier(name)
 
@@ -104,3 +112,4 @@ object RootIdentifier extends SpecialIdentifier(Identifier.ROOT)
 object ParentIdentifier extends SpecialIdentifier(Identifier.PARENT)
 object IoIdentifier extends SpecialIdentifier(Identifier.IO)
 object EndianIdentifier extends SpecialIdentifier(Identifier.IS_LE)
+
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/CSharpCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/CSharpCompiler.scala
index 991b0e7d4..b2731e557 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/CSharpCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/CSharpCompiler.scala
@@ -17,7 +17,6 @@ class CSharpCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with AllocateIOLocalVar
     with EveryReadIsExpression
     with UniversalDoc
-    with FixedContentsUsingArrayByteLiteral
     with SwitchIfOps
     with NoNeedForFullClassPath {
   import CSharpCompiler._
@@ -193,9 +192,6 @@ class CSharpCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    out.puts(s"${privateMemberName(attrName)} = $normalIO.EnsureFixedContents($contents);")
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -272,7 +268,7 @@ class CSharpCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.inc
   }
 
-  override def condIfFooter(expr: expr): Unit = fileFooter(null)
+  override def condIfFooter: Unit = fileFooter(null)
 
   override def condRepeatInitAttr(id: Identifier, dataType: DataType): Unit = {
     importList.add("System.Collections.Generic")
@@ -580,17 +576,21 @@ class CSharpCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = CSharpCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "null",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     out.puts(s"if (!(${translator.translate(checkExpr)}))")
     out.puts("{")
     out.inc
-    out.puts(s"throw new ${ksErrorName(err)}($errArgsStr);")
+    out.puts(s"throw new ${ksErrorName(err)}(${errArgsStr.mkString(", ")});")
     out.dec
     out.puts("}")
   }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/CppCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/CppCompiler.scala
index afef98f43..b6d93d31e 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/CppCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/CppCompiler.scala
@@ -16,7 +16,6 @@ class CppCompiler(
 ) extends LanguageCompiler(typeProvider, config)
     with ObjectOrientedLanguage
     with AllocateAndStoreIO
-    with FixedContentsUsingArrayByteLiteral
     with UniversalDoc
     with SwitchIfOps
     with EveryReadIsExpression {
@@ -452,9 +451,6 @@ class CppCompiler(
     outSrc.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    outSrc.puts(s"${privateMemberName(attrName)} = $normalIO->ensure_fixed_contents($contents);")
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -570,7 +566,7 @@ class CppCompiler(
     outSrc.inc
   }
 
-  override def condIfFooter(expr: Ast.expr): Unit = {
+  override def condIfFooter: Unit = {
     outSrc.dec
     outSrc.puts("}")
   }
@@ -1018,17 +1014,21 @@ class CppCompiler(
   }
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else nullPtr,
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     importListSrc.addKaitai("kaitai/exceptions.h")
     outSrc.puts(s"if (!(${translator.translate(checkExpr)})) {")
     outSrc.inc
-    outSrc.puts(s"throw ${ksErrorName(err)}($errArgsStr);")
+    outSrc.puts(s"throw ${ksErrorName(err)}(${errArgsStr.mkString(", ")});")
     outSrc.dec
     outSrc.puts("}")
   }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/GoCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/GoCompiler.scala
index 4afa8dae4..e73bbad7c 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/GoCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/GoCompiler.scala
@@ -3,10 +3,12 @@ package io.kaitai.struct.languages
 import io.kaitai.struct.datatype.DataType._
 import io.kaitai.struct.datatype._
 import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.exprlang.Ast.expr.{IntNum, InternalName}
 import io.kaitai.struct.format._
 import io.kaitai.struct.languages.components._
-import io.kaitai.struct.translators.{GoTranslator, ResultString, TranslatorResult}
+import io.kaitai.struct.translators.GoTranslator
 import io.kaitai.struct.{ClassTypeProvider, RuntimeConfig, Utils}
+import io.kaitai.struct.precompile.TypeMismatchError
 
 class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   extends LanguageCompiler(typeProvider, config)
@@ -15,11 +17,21 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with ObjectOrientedLanguage
     with UniversalFooter
     with UniversalDoc
+    with GoWrites
+    with FetchInstances
     with AllocateIOLocalVar
     with GoReads {
   import GoCompiler._
 
-  override val translator = new GoTranslator(out, typeProvider, importList)
+  private var inSubIOWriteBackHandler = false
+
+  private var inSwitchCaseHandler = false
+
+  private var nowPosName = ""
+
+  override val translator = new GoTranslator(out, typeProvider, importList, config)
+
+  var procStack: scala.collection.mutable.Map[String, () => Unit] = scala.collection.mutable.Map()
 
   override def innerClasses = false
 
@@ -59,6 +71,10 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts
   }
 
+  override def classExtendMarks(name: List[String]): Unit = {
+    name.foreach(x => out.puts(s"$x"))
+  }
+
   override def classHeader(name: List[String]): Unit = {
     out.puts(s"type ${types2class(name)} struct {")
     out.inc
@@ -78,18 +94,289 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     val paramsArg = params.map((p) =>
       s"${paramName(p.id)} ${kaitaiType2NativeType(p.dataType)}"
     ).mkString(", ")
-    out.puts(s"func New${types2class(name)}($paramsArg) *${types2class(name)} {")
+
+    out.puts
+    out.puts(s"func New${types2class(name)}(_io *kaitai.Stream, _parent ${kaitaiType2NativeType(parentType)}, _root *${type2class(rootClassName(0))}) *${types2class(name)} {")
+    out.inc
+    out.puts(s"if _io == nil${if (parentType == AnyType) "&& _parent != nil" else ""} {")
     out.inc
-    out.puts(s"return &${types2class(name)}{")
+    out.puts(s"_io = ${if (kaitaiType2NativeType(parentType) == "*kaitai.Stream") "_parent" else if (parentType == AnyType) "_parent.Get_io()" else "_parent._io"} ")
+    out.dec
+    out.puts("}")
+    out.puts(s"s := &${types2class(name)}{")
     out.inc
-    params.foreach(p => out.puts(s"${idToStr(p.id)}: ${paramName(p.id)},"))
+    out.puts("_io: _io, _parent: _parent, _root: _root,")
     out.dec
     out.puts("}")
+    out.puts("if _root == nil {")
+    out.inc
+    if (type2class(rootClassName(0)) == types2class(name)) {
+      out.puts("s._root = s")
+    } else {
+      out.puts(s"s._root = New${type2class(rootClassName(0))}(_io, _io, nil)")
+    }
     universalFooter
+    out.puts("return s")
+    universalFooter
+    instanceSizeOf(types2class(name))
   }
 
   override def classConstructorFooter: Unit = {}
 
+  def terminatorConstructor(id: String, dt: DataType, params: scala.collection.mutable.Map[String, Any]): String = {
+    val (valueType, returnType, tag) = dt match {
+      case _: StrFromBytesType => ("string", kTerminatedType.format("String"), "String")
+      case _: BytesTerminatedType => ("[]byte", kTerminatedType.format("Bytes"), "Bytes")
+      case _ =>
+        throw new TypeMismatchError(s"bad terminator type, got ${dt.toString}")
+    }
+    out.puts
+    out.puts(s"func (this ${types2class(typeProvider.nowClass.name)}) New_${id}TerminatedType(value $valueType) *$returnType {")
+    out.inc
+    if (params.getOrElse("encoding", "").asInstanceOf[String].contains("US-ASCII")) {
+      val r = translator.allocateLocalVar()
+      out.puts(s"encoder$r, _ := ${params.getOrElse("encoding", "").asInstanceOf[String]}")
+      params("encoding") = s"encoder$r"
+    }
+    out.puts(s"${valueType.stripPrefix("[]")}Type := kaitai.New${tag}TerminatedType(${(if (params.get("encoding") == None) "" else params("encoding") + ", ") + params("terminator") + ", " + params("include") + ", " + params("consume") + ", " + params("eosError")})")
+    out.puts(s"${valueType.stripPrefix("[]")}Type.Data = value")
+    out.puts(s"return ${valueType.stripPrefix("[]")}Type")
+    out.dec
+    out.puts("}")
+
+    out.result
+  }
+
+  override def fetchInstancesHeader(): Unit = {
+    out.puts
+    out.puts(
+      s"func (this *${types2class(typeProvider.nowClass.name)}) fetchInstances() (err error) {".stripMargin)
+    out.inc
+
+    translator.returnRes = None
+  }
+
+  override def fetchInstancesFooter(): Unit = {
+    out.puts("return err")
+    out.dec
+    out.puts("}")
+  }
+
+  override def attrInvokeFetchInstances(baseExpr: Ast.expr, exprType: DataType, dataType: DataType): Unit = {
+    val expr = expression(baseExpr)
+    var tmpVarName = ""
+    if (inSwitchCaseHandler && (exprType == AnyType || exprType == CalcAnyType)) {
+      tmpVarName = translator.interfaceTypeOfSwitchCase(expr, kaitaiType2NativeType(dataType))
+    }
+
+    out.puts(s"err = ${if (tmpVarName == "") expr else tmpVarName }.fetchInstances()")
+    translator.outAddErrCheck()
+  }
+
+  override def attrInvokeInstance(instName: InstanceIdentifier): Unit = {}
+
+  override def runWriteCalc(): Unit = {
+    out.puts
+    out.puts(s"switch ${privateMemberName(EndianIdentifier)} {")
+    out.puts("case 0:")
+    out.inc
+    out.puts("err = this.writebe()")
+    out.dec
+    out.puts("case 1:")
+    out.inc
+    out.puts("err = this.writele()")
+    out.dec
+    out.puts("default:")
+    out.inc
+    out.puts(s"err = ${GoCompiler.ksErrorName(UndecidedEndiannessError)}{}")
+    out.dec
+    out.puts("}")
+  }
+
+  override def writeHeader(endian: Option[FixedEndian], isEmpty: Boolean): Unit = {
+    out.puts
+    endian match {
+      case None =>
+        out.puts(
+          s"func (this *${types2class(typeProvider.nowClass.name)}) Write() (err error) {"
+        )
+        out.inc
+        out.puts("err = this.WriteSeq(this._io)")
+        translator.returnRes = None
+        translator.outAddErrCheck()
+        out.puts("err = this.fetchInstances()")
+        translator.returnRes = None
+        translator.outAddErrCheck()
+        out.puts("return this._io.WriteBackChildStreams()")
+        out.dec
+        out.puts("}")
+        out.puts
+        out.puts(
+          s"func (this *${types2class(typeProvider.nowClass.name)}) WriteSeq(inputIO *$kstreamName) (err error) {"
+        )
+        out.inc
+        out.puts(s"${privateMemberName(IoIdentifier)} = inputIO")
+        typeProvider.nowClass.meta.endian match {
+          case Some(_: CalcEndian) =>
+            out.puts(s"${privateMemberName(EndianIdentifier)} = -1")
+          case Some(InheritedEndian) =>
+            out.puts(s"${privateMemberName(EndianIdentifier)} = " +
+              s"${privateMemberName(ParentIdentifier)}." +
+              s"${idToStr(EndianIdentifier)}")
+          case _ =>
+        }
+        out.puts
+        translator.returnRes = None
+      case Some(e) =>
+        out.puts
+        out.puts(
+          s"func (this *${types2class(typeProvider.nowClass.name)}) write${e.toSuffix}() (err error) {")
+        out.inc
+        translator.returnRes = None
+    }
+  }
+
+  override def writeFooter(): Unit = {
+    out.puts("return err")
+    universalFooter
+
+    procStack.foreach(r => r._2())
+  }
+
+  override def writeInstanceHeader(instName: InstanceIdentifier): Unit = {
+    out.puts
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) Write${publicMemberName(instName)}() (err error) {")
+    out.inc
+    instanceClearWriteFlag(instName)
+
+    translator.returnRes = None
+  }
+
+  override def writeInstanceFooter(): Unit = {
+    out.puts("return nil")
+    out.dec
+    out.puts("}")
+  }
+  // override def attrWrite(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit = ???
+
+  override def checkHeader(): Unit = {
+    out.puts
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) Check() error {")
+    out.inc
+
+    translator.returnRes = None
+  }
+  override def checkFooter(): Unit = {
+    out.puts("return nil")
+    out.dec
+    out.puts("}")
+  }
+
+  override def checkInstanceHeader(instName: InstanceIdentifier): Unit = {
+    out.puts
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) Check${publicMemberName(instName)}() (err error) {")
+    out.inc
+
+    translator.returnRes = None
+  }
+
+  override def checkInstanceFooter(): Unit = {
+    out.puts("return nil")
+    out.dec
+    out.puts("}")
+  }
+  // override def attrCheck(attr: AttrLikeSpec, id: Identifier): Unit = ???
+
+  override def condRepeatCommonHeader(id: Identifier, io: String, dataType: DataType): Unit = {
+    out.puts(s"for i := 0; i < len(${privateMemberName(id)}); i++ {")
+    out.inc
+  }
+  // override def condRepeatCommonFooter: Unit = {}
+
+  override def exprIORemainingSize(io: String): String = {
+    out.puts(s"size, err := $io.Size()")
+    translator.outAddErrCheck()
+    out.puts(s"pos, err := $io.Pos()")
+    translator.outAddErrCheck()
+    s"size - pos"
+  }
+
+  override def subIOWriteBackHeader(subIO: String, process: Option[ProcessExpr]): String = {
+    val parentIoName = "parent"
+
+    out.puts(s"$subIO.SetWriteBackHandler(kaitai.NewWriteBackHandler(${nowPosName}, func($parentIoName *$kstreamName) error {")
+    inSubIOWriteBackHandler = true
+    out.inc
+    translator.returnRes = None
+    parentIoName
+  }
+
+  override def subIOWriteBackSetter(subIO: String): Unit = {
+    out.puts(s"$subIO.SetWriteBackHandler(NewSubIO())")
+  }
+
+  override def subIOWriteBackFooter(subIO: String): Unit = {
+    inSubIOWriteBackHandler = false
+    out.puts("return err")
+    out.dec
+    out.puts("}))")
+    out.puts
+  }
+
+  override def addChildIO(io: String, childIO: String): Unit = {
+    out.puts(s"$io.AddChildStream($childIO)")
+  }
+
+  override def instanceWriteFlagDeclaration(attrName: InstanceIdentifier): Unit = {
+    out.puts(s"_write${publicMemberName(attrName)} bool")
+    out.puts(s"_toWrite${publicMemberName(attrName)} bool")
+  }
+
+  // override def instanceWriteFlagInit(attrName: InstanceIdentifier): Unit = {}
+  override def instanceSetWriteFlag(instName: InstanceIdentifier): Unit = {
+    out.puts(s"this._write${publicMemberName(instName)} = this._toWrite${publicMemberName(instName)}")
+  }
+
+  override def instanceClearWriteFlag(instName: InstanceIdentifier): Unit = {
+    out.puts(s"this._write${publicMemberName(instName)} = false")
+  }
+
+  override def instanceToWriteSetter(instName: InstanceIdentifier): Unit = {
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) set${publicMemberName(instName)}ToWrite(_v bool) { this._toWrite${publicMemberName(instName)} = _v }")
+  }
+
+  override def instanceInvalidate(instName: InstanceIdentifier): Unit = {
+    // go can not convert num to bool directly
+    val actualNameAndType = instName.name.split("_insplit_")
+    val actualInst = InstanceIdentifier(actualNameAndType(0))
+    var instType = "0"
+    if ( actualNameAndType.length == 2 ) {
+      if (actualNameAndType(1).contains("bool")) {
+        instType = "false"
+      } else if (actualNameAndType(1).contains("usertype") || actualNameAndType(1).contains("arraytype") || actualNameAndType(1).contains("bytestype")) {
+        if (out.result.contains(s"${privateMemberName(actualInst).split("\\.").last} string")) {
+          instType = "\"\""
+        } else {
+          instType = "nil"
+        }
+      } else if (actualNameAndType(1).contains("str")) {
+        instType = "\"\""
+      }
+    }
+
+
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) Invalidate${publicMemberName(actualInst)}() { ${privateMemberName(actualInst)} = $instType; this.${calculatedFlagForName(actualInst)} = false; }")
+  }
+
+  override def instanceCheckWriteFlagAndWrite(instName: InstanceIdentifier): Unit = {
+    out.puts(s"if this._write${publicMemberName(instName)} {")
+    out.inc
+    out.puts(s"err := this.Write${publicMemberName(instName)}()")
+    translator.outAddErrCheck()
+    out.dec
+    out.puts("}")
+  }
+
   override def runRead(name: List[String]): Unit = {
     out.puts("this.Read()")
   }
@@ -117,15 +404,9 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
       case None =>
         out.puts
         out.puts(
-          s"func (this *${types2class(typeProvider.nowClass.name)}) Read(" +
-            s"io *$kstreamName, " +
-            s"parent ${kaitaiType2NativeType(typeProvider.nowClass.parentType)}, " +
-            s"root *${types2class(typeProvider.topClass.name)}) (err error) {"
+          s"func (this *${types2class(typeProvider.nowClass.name)}) Read() (err error) {"
         )
         out.inc
-        out.puts(s"${privateMemberName(IoIdentifier)} = io")
-        out.puts(s"${privateMemberName(ParentIdentifier)} = parent")
-        out.puts(s"${privateMemberName(RootIdentifier)} = root")
         typeProvider.nowClass.meta.endian match {
           case Some(_: CalcEndian) =>
             out.puts(s"${privateMemberName(EndianIdentifier)} = -1")
@@ -135,19 +416,22 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
               s"${idToStr(EndianIdentifier)}")
           case _ =>
         }
-        out.puts
+        translator.returnRes = None
       case Some(e) =>
         out.puts
         out.puts(
           s"func (this *${types2class(typeProvider.nowClass.name)}) " +
             s"_read_${e.toSuffix}() (err error) {")
         out.inc
+        translator.returnRes = None
     }
 
   }
-  override def readFooter(): Unit = {
+  override def readFooter: Unit = {
     out.puts("return err")
     universalFooter
+    translator.terminatedTypesStack.foreach(fn => out.puts(fn()))
+    translator.terminatedTypesStack = List()
   }
 
   override def attributeDeclaration(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
@@ -155,7 +439,22 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     translator.returnRes = None
   }
 
-  override def attributeReader(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {}
+  override def attributeReader(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
+    if (idToStr(attrName) == "_io") {
+      out.puts
+      out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) Get${idToStr(attrName)}() ${kaitaiType2NativeType(attrType)} { return this.${idToStr(attrName)} }")
+    }
+  }
+  override def attributeSetter(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
+    val goType = kaitaiType2NativeType(attrType)
+    val name = idToStr(attrName)
+
+    out.puts
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) Set${idToStr(attrName)}(_v $goType) { this.$name = _v; }")
+  }
+  override def attrSetProperty(base: Ast.expr, propName: Identifier, value: String): Unit = {
+    out.puts(s"${expression(base)}.${publicMemberName(propName)} = $value")
+  }
 
   override def universalDoc(doc: DocSpec): Unit = {
     out.puts
@@ -190,25 +489,6 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: Array[Byte]): Unit = {
-    out.puts(s"${privateMemberName(attrName)}, err = $normalIO.ReadBytes(${contents.length})")
-
-    out.puts(s"if err != nil {")
-    out.inc
-    out.puts("return err")
-    out.dec
-    out.puts("}")
-
-    importList.add("bytes")
-    importList.add("errors")
-    val expected = translator.resToStr(translator.doByteArrayLiteral(contents))
-    out.puts(s"if !bytes.Equal(${privateMemberName(attrName)}, $expected) {")
-    out.inc
-    out.puts("return errors.New(\"Unexpected fixed contents\")")
-    out.dec
-    out.puts("}")
-  }
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -221,7 +501,7 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
             s"kaitai.ProcessXOR($srcExpr, ${expression(xorValue)})"
         }
       case ProcessZlib =>
-        translator.resToStr(translator.outVarCheckRes(s"kaitai.ProcessZlib($srcExpr)"))
+        translator.outVarCheckRes(s"kaitai.ProcessZlib($srcExpr)")
       case ProcessRotate(isLeft, rotValue) =>
         val expr = if (isLeft) {
           expression(rotValue)
@@ -233,25 +513,30 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
         // TODO(jchw): This hack is necessary because Go tests fail catastrophically otherwise...
         s"$srcExpr"
     }
-    handleAssignment(varDest, ResultString(expr), rep, false)
+    handleAssignment(varDest, expr, rep, false)
   }
 
   override def allocateIO(varName: Identifier, rep: RepeatSpec): String = {
-    val javaName = privateMemberName(varName)
-
     val ioName = idToStr(IoStorageIdentifier(varName))
-
     val args = rep match {
       case RepeatUntil(_) => translator.specialName(Identifier.ITERATOR2)
       case _ => getRawIdExpr(varName, rep)
     }
 
-    importList.add("bytes")
+    importList.add("github.com/kaitai-io/kaitai_struct_go_runtime/buffer")
+    out.puts(s"$ioName := kaitai.NewStream(buffer.NewSeekableBufferWithBytes($args))")
+    ioName
+  }
 
-    out.puts(s"$ioName := kaitai.NewStream(bytes.NewReader($args))")
+  override def allocateIOFixed(varName: Identifier, size: String): String = {
+    val ioName = idToStr(IoStorageIdentifier(varName))
+    out.puts(s"$ioName := kaitai.NewStream(buffer.NewSeekableBufferWithBytes(make([]byte, $size)))")
     ioName
   }
 
+  override def allocateIOGrowing(varName: Identifier): String =
+    allocateIOFixed(varName, "100000")
+
   def getRawIdExpr(varName: Identifier, rep: RepeatSpec): String = {
     val memberName = privateMemberName(varName)
     rep match {
@@ -271,6 +556,13 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     translator.outAddErrCheck()
   }
 
+  override def pushPosForSubIOWriteBackHandler(io: String): Unit = {
+    importList.add("io")
+    nowPosName = s"pos${translator.allocateLocalVar()}"
+    out.puts(s"$nowPosName, err := $io.Pos()")
+    translator.outAddErrCheck()
+  }
+
   override def seek(io: String, pos: Ast.expr): Unit = {
     importList.add("io")
 
@@ -278,10 +570,15 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     translator.outAddErrCheck()
   }
 
+  override def seekRelative(io: String, relPos: String): Unit = {
+    importList.add("io")
+    out.puts(s"$io.Seek(int64($relPos), io.SeekCurrent)")
+  }
+
   override def popPos(io: String): Unit = {
     importList.add("io")
 
-    out.puts(s"_, err = $io.Seek(_pos, io.SeekStart)")
+    out.puts(s"_, err = $io.Seek(int64(_pos), io.SeekStart)")
     translator.outAddErrCheck()
   }
 
@@ -289,13 +586,14 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"$io.AlignToByte()")
 
   override def condIfHeader(expr: Ast.expr): Unit = {
-    out.puts(s"if (${expression(expr)}) {")
+    out.puts(s"if ${expression(expr)} {")
     out.inc
   }
 
   override def condRepeatInitAttr(id: Identifier, dataType: DataType): Unit = {
     // slices don't have to be manually initialized in Go: the built-in append()
     // function works even on `nil` slices (https://go.dev/tour/moretypes/15)
+    out.puts(s"${privateMemberName(id)} = make(${kaitaiType2NativeType(ArrayTypeInStream(dataType))}, 0)")
   }
 
   override def condRepeatEosHeader(id: Identifier, io: String, dataType: DataType): Unit = {
@@ -312,9 +610,9 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def handleAssignmentRepeatEos(id: Identifier, r: TranslatorResult): Unit = {
+  override def handleAssignmentRepeatEos(id: Identifier, r: String): Unit = {
     val name = privateMemberName(id)
-    val expr = translator.resToStr(r)
+    val expr = r
     out.puts(s"$name = append($name, $expr)")
   }
 
@@ -329,7 +627,7 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("_ = i")
   }
 
-  override def handleAssignmentRepeatExpr(id: Identifier, r: TranslatorResult): Unit =
+  override def handleAssignmentRepeatExpr(id: Identifier, r: String): Unit =
     handleAssignmentRepeatEos(id, r)
 
   override def condRepeatUntilHeader(id: Identifier, io: String, dataType: DataType, untilExpr: Ast.expr): Unit = {
@@ -337,8 +635,8 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.inc
   }
 
-  override def handleAssignmentRepeatUntil(id: Identifier, r: TranslatorResult, isRaw: Boolean): Unit = {
-    val expr = translator.resToStr(r)
+  override def handleAssignmentRepeatUntil(id: Identifier, r: String, isRaw: Boolean): Unit = {
+    val expr = r
     val tempVar = translator.specialName(if (isRaw) Identifier.ITERATOR2 else Identifier.ITERATOR)
     out.puts(s"$tempVar := $expr")
     out.puts(s"${privateMemberName(id)} = append(${privateMemberName(id)}, $tempVar)")
@@ -355,10 +653,10 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  private def castToType(r: TranslatorResult, dataType: DataType): TranslatorResult = {
+  private def castToType(r: String, dataType: DataType): String = {
     dataType match {
-      case t @ (_: IntMultiType | _: FloatMultiType) =>
-        ResultString(s"${kaitaiType2NativeType(t)}(${translator.resToStr(r)})")
+      case t @ (_: IntMultiType | _: FloatMultiType | CalcIntType | CalcFloatType) =>
+        s"${kaitaiType2NativeType(t)}(${r})"
       case _ =>
         r
     }
@@ -371,7 +669,7 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     }
   }
 
-  private def handleCompositeTypeCast(id: Identifier, r: TranslatorResult): TranslatorResult = {
+  def handleCompositeTypeCast(id: Identifier, r: String): String = {
     id match {
       case NamedIdentifier(name) =>
         castToType(r, combinedType(typeProvider.determineType(name)))
@@ -380,13 +678,23 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     }
   }
 
-  override def handleAssignmentSimple(id: Identifier, r: TranslatorResult): Unit = {
-    val expr = translator.resToStr(handleCompositeTypeCast(id, r))
-    out.puts(s"${privateMemberName(id)} = $expr")
+  override def handleAssignmentSimple(id: Identifier, r: String): Unit = {
+    val expr = handleCompositeTypeCast(id, r)
+    out.puts(s"${privateMemberName(id)}${if (translator.returnRes != None && translator.returnRes.get == "err") ", err" else "" } = $expr")
+    if (translator.returnRes != None && translator.returnRes.get == "err") {
+      translator.returnRes = None
+      translator.outAddErrCheck()
+    }
   }
 
-  def handleAssignmentTempVar(dataType: DataType, id: String, expr: String): Unit =
+  override def handleAssignmentTempVar(dataType: DataType, id: String, expr: String): Unit = {
     out.puts(s"$id := $expr")
+  }
+  def handleAssignmentError(id: Identifier, r: String): Unit = {
+    val expr = handleCompositeTypeCast(id, r)
+    out.puts(s"${privateMemberName(id)}, err = $expr")
+    translator.outAddErrCheck()
+  }
 
   override def blockScopeHeader: Unit = {
     out.puts("{")
@@ -413,7 +721,7 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
           ""
         } else {
           val parent = t.forcedParent match {
-            case Some(USER_TYPE_NO_PARENT) => "null"
+            case Some(USER_TYPE_NO_PARENT) => "nil"
             case Some(fp) => translator.translate(fp)
             case None => "this"
           }
@@ -437,24 +745,32 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
   override def switchStart(id: Identifier, on: Ast.expr): Unit = {
     out.puts(s"switch (${expression(on)}) {")
+    inSwitchCaseHandler = true
   }
 
   override def switchCaseStart(condition: Ast.expr): Unit = {
     out.puts(s"case ${expression(condition)}:")
     out.inc
+
+    inSwitchCaseHandler = true
   }
 
   override def switchCaseEnd(): Unit = {
     out.dec
+    inSwitchCaseHandler = false
   }
 
   override def switchElseStart(): Unit = {
     out.puts("default:")
     out.inc
+
+    inSwitchCaseHandler = true
   }
 
-  override def switchEnd(): Unit =
+  override def switchEnd(): Unit = {
     out.puts("}")
+    inSwitchCaseHandler = false
+  }
 
   override def switchShouldUseCompareFn(onType: DataType): (Option[String], () => Unit) = {
     onType match {
@@ -468,6 +784,8 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def switchCaseStartCompareFn(compareFn: String, switchOn: Ast.expr, condition: Ast.expr): Unit = {
     out.puts(s"case ${compareFn}(${expression(switchOn)}, ${expression(condition)}):")
     out.inc
+
+    inSwitchCaseHandler = true
   }
 
   override def instanceDeclaration(attrName: InstanceIdentifier, attrType: DataType, isNullable: Boolean): Unit = {
@@ -475,28 +793,119 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"${idToStr(attrName)} ${kaitaiType2NativeType(attrType)}")
   }
 
+  override def instanceSetter(className: List[String], instName: InstanceIdentifier, dataType: DataType): Unit = {
+    out.puts
+    out.puts(s"func (this *${types2class(className)}) Set${publicMemberName(instName)}(v ${kaitaiType2NativeType(dataType)}) {")
+    out.inc
+    out.puts(s"this.${calculatedFlagForName(instName)} = true")
+    out.puts(s"this.${publicMemberName(instName)} = v")
+    out.dec
+    out.puts("}")
+  }
+
   override def instanceHeader(className: List[String], instName: InstanceIdentifier, dataType: DataType, isNullable: Boolean): Unit = {
-    out.puts(s"func (this *${types2class(className)}) ${publicMemberName(instName)}() (v ${kaitaiType2NativeType(dataType)}, err error) {")
+    out.puts(s"func (this *${types2class(className)}) Get${publicMemberName(instName)}() (v ${kaitaiType2NativeType(dataType)}, err error) {")
     out.inc
     translator.returnRes = Some(dataType match {
       case _: NumericType => "0"
       case _: BooleanType => "false"
-      case _: StrType => "\"\""
+      case st: StrType => {
+        st match {
+          case sbt: StrFromBytesType if sbt.bytes.isInstanceOf[BytesTerminatedType] => "nil"
+          case _ => "\"\""
+        }
+      }
       case _ => "nil"
     })
   }
 
+  def instanceSizeOf(className: String): Unit = {
+    out.puts
+    out.puts(s"func (this *$className) SizeOf() (uint64, error) {")
+    out.inc
+    out.puts("return kaitai.SizeOf(this)")
+    out.dec
+    out.puts("}")
+  }
+
+  def preHandleGoAst(ast: Ast.expr): Ast.expr = {
+    ast match {
+      case Ast.expr.BinOp(left, op, right) => {
+        Ast.expr.BinOp(preHandleGoAst(left), op, preHandleGoAst(right))
+      }
+      case _ => ast
+    }
+  }
+
+  case class Mut[A](var value: A) {}
+
+  def walkAllAttrExpr(value: Ast.expr, mut_stack: Mut[List[String]]): (Ast.expr, String) = {
+    value match {
+      case Ast.expr.Attribute(v, attr) => {
+        val dt = translator.detectType(v)
+        if (dt == AnyType || dt == CalcAnyType) {
+          return (v, "kaitai.AnyTypeInterface")
+        }
+        if (dt.isInstanceOf[CalcUserType]) {
+          mut_stack.value = mut_stack.value.+:(attr.name)
+          return (v, kaitaiType2NativeType(dt))
+        }
+        mut_stack.value = mut_stack.value.+:(attr.name)
+        walkAllAttrExpr(v, mut_stack)
+      }
+      case Ast.expr.CastToType(v, typeName) => {
+        val dt = translator.detectType(v)
+        if (dt == AnyType || dt == CalcAnyType) {
+          return (v, "kaitai.AnyTypeInterface")
+        }
+        if (dt.isInstanceOf[CalcUserType]) {
+          mut_stack.value = mut_stack.value.+:(typeName.names.headOption.getOrElse(""))
+          return (v, kaitaiType2NativeType(dt))
+        }
+        mut_stack.value = mut_stack.value.+:(typeName.names.headOption.getOrElse(""))
+        walkAllAttrExpr(v, mut_stack)
+      }
+      case _ => (value, "")
+    }
+  }
+
   override def instanceCalculate(instName: Identifier, dataType: DataType, value: Ast.expr): Unit = {
-    val r = translator.translate(value)
+    var r = translator.translate(value)
+    var walkedValue: Mut[List[String]] = Mut(List())
+
+    val (backedValue, walkedValueRes) = walkAllAttrExpr(value, walkedValue)
+    if (walkedValueRes != "" && walkedValueRes != "kaitai.AnyTypeInterface" && walkedValueRes != "interface{}" && !r.contains(".(*") ) {
+      val (front, back) = r.splitAt(r.indexOf(walkedValue.value(0).capitalize))
+      val splitedFront = front.split("\\.")
+      if (kaitaiType2NativeType(translator.detectType(backedValue)) == "kaitai.AnyTypeInterface" || kaitaiType2NativeType(translator.detectType(backedValue))  == "interface{}" || splitedFront.length >= 3) {
+        r = front ++ s"($walkedValueRes)." ++ back
+      } else {
+        r = front ++ back
+      }
+    } else if (walkedValueRes == "kaitai.AnyTypeInterface" || walkedValueRes == "interface{}") {
+      r = s"$r.(${kaitaiType2NativeType(dataType)})"
+    }
+
     val converted = dataType match {
       case _: UserType => r
-      case _ => s"${kaitaiType2NativeType(dataType)}($r)"
+      case st: StrFromBytesType if st.bytes.isInstanceOf[BytesTerminatedType] => r
+      case _ => {
+        // TODO: ugly
+        val tmpResult = out.result
+        if (tmpResult.contains(s"$r *kaitai.StringTerminatedType")) {
+          s"$r.String()"
+        } else if (tmpResult.contains(s"$r *kaitai.BytesTerminatedType")) {
+          s"$r.Bytes()"
+        } else {
+          s"${kaitaiType2NativeType(dataType)}($r)"
+        }
+      }
     }
     out.puts(s"${privateMemberName(instName)} = $converted")
   }
 
   override def instanceCheckCacheAndReturn(instName: InstanceIdentifier, dataType: DataType): Unit = {
-    out.puts(s"if (this.${calculatedFlagForName(instName)}) {")
+    out.puts(s"if this.${calculatedFlagForName(instName)} {")
     out.inc
     instanceReturn(instName, dataType)
     universalFooter
@@ -510,11 +919,33 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"this.${calculatedFlagForName(instName)} = true")
 
   override def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit = {
-    val fullEnumName: List[String] = curClass ++ List(enumName)
+    val actualNameAndType = enumName.split("_insplit_")
+    var typeName = "int"
+    val actualEnumName = actualNameAndType(0)
+
+    val fullEnumName: List[String] = curClass ++ List(actualEnumName)
     val fullEnumNameStr = types2class(fullEnumName)
 
+    if (actualNameAndType.length == 2) {
+      val splittedType = actualNameAndType(1).split(",")
+      if (splittedType.length >= 1) {
+        if (splittedType(0).contains("false")) {
+          typeName = "uint"
+        }
+        if (splittedType.length >= 2) {
+          splittedType(1) match {
+            case "Width1" => typeName += "8"
+            case "Width2" => typeName += "16"
+            case "Width4" => typeName += "32"
+            case "Width8" => typeName += "64"
+            case _ => typeName
+          }
+        }
+      }
+    }
+
     out.puts
-    out.puts(s"type $fullEnumNameStr int")
+    out.puts(s"type $fullEnumNameStr $typeName")
     out.puts("const (")
     out.inc
 
@@ -528,7 +959,7 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
   override def classToString(toStringExpr: Ast.expr): Unit = {
     out.puts
-    out.puts(s"func (this ${types2class(typeProvider.nowClass.name)}) String() string {")
+    out.puts(s"func (this *${types2class(typeProvider.nowClass.name)}) String() string {")
     out.inc
     out.puts(s"return ${translator.translate(toStringExpr)}")
     out.dec
@@ -550,61 +981,329 @@ class GoCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = GoCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "nil",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     out.puts(s"if !(${translator.translate(checkExpr)}) {")
     out.inc
-    val errInst = s"kaitai.New${err.name}($errArgsStr)"
+    val errInst = s"kaitai.New${err.name}(${errArgsStr.mkString(", ")})"
     val noValueAndErr = translator.returnRes match {
       case None => errInst
-      case Some(r) => s"$r, $errInst"
+      case Some(r) => {
+        if (r == "nil") {
+          errInst
+        } else {
+          s"$r, $errInst"
+        }
+      }
     }
     out.puts(s"return $noValueAndErr")
     out.dec
     out.puts("}")
   }
-}
 
-object GoCompiler extends LanguageCompilerStatic
-  with UpperCamelCaseClasses
-  with StreamStructNames
-  with ExceptionNames {
+  override def internalEnumIntType(basedOn: IntType): DataType = {
+    basedOn match {
+      case IntMultiType(signed, _, endian) => IntMultiType(signed, Width8, endian)
+      case _ => IntMultiType(signed = true, Width8, None)
+    }
+  }
 
-  override def getCompiler(
-    tp: ClassTypeProvider,
-    config: RuntimeConfig
-  ): LanguageCompiler = new GoCompiler(tp, config)
+  def castIfNeeded(exprRaw: String, exprType: DataType, targetType: DataType): String =
+    if (exprRaw.contains(".(")) {
+      exprRaw
+    } else {
+      if (exprType != targetType || exprRaw.startsWith("(len")) {
+        val castTypeId = kaitaiType2NativeType(targetType)
+        targetType match {
+          case _: NumericType => {
+            val resType = exprType match {
+              case AnyType | CalcAnyType => s"$exprRaw.($castTypeId)"
+              case _ => s"$castTypeId($exprRaw)"
+            }
+            resType
+          }
+          case _: BytesType | _: BytesLimitType | _: BytesEosType => {
+            if (exprRaw.contains("_raw_")) {
+              return s"$exprRaw"
+            }
+            val resType = exprType match {
+              case AnyType | CalcAnyType => s"$exprRaw.($castTypeId)"
+              case _ => s"$exprRaw"
+            }
+            resType
+          }
+          // case _ : CalcUserType => s"${castTypeId.stripPrefix("*")}{ReadWriteStream: $exprRaw}"
+          case _ => s"$exprRaw"
+        }
+      } else {
+        exprRaw
+      }
+    }
 
-  def idToStr(id: Identifier): String =
-    id match {
-      case SpecialIdentifier(name) => name
-      case NamedIdentifier(name) => Utils.upperCamelCase(name)
-      case NumberedIdentifier(idx) => s"_${NumberedIdentifier.TEMPLATE}$idx"
-      case InstanceIdentifier(name) => Utils.lowerCamelCase(name)
-      case RawIdentifier(innerId) => s"_raw_${idToStr(innerId)}"
-      case IoStorageIdentifier(innerId) => s"_io_${idToStr(innerId)}"
+  override def attrPrimitiveWrite(io: String, expr: Ast.expr, dt: DataType, defEndian: Option[FixedEndian], exprTypeOpt: Option[DataType]): Unit = {
+    val exprType = exprTypeOpt.getOrElse(dt)
+    var exprRaw = expression(expr)
+    var exprProcessed = castIfNeeded(exprRaw, exprType, dt)
+
+    if (exprRaw.contains(";")) {
+      val newedExprRaw = exprRaw.split(";")
+      out.puts(newedExprRaw(0))
+      translator.returnRes = None
+      translator.outAddErrCheck()
+      exprRaw = newedExprRaw(1)
+      out.puts(s"${newedExprRaw(0).split(",")(0)} = ${newedExprRaw(0).split(",")(0)}")
+      exprProcessed = castIfNeeded(exprRaw, exprType, dt)
     }
 
-  def publicMemberName(id: Identifier): String =
-    id match {
-      case IoIdentifier => "_IO"
-      case RootIdentifier => "_Root"
-      case ParentIdentifier => "_Parent"
-      case InstanceIdentifier(name) => Utils.upperCamelCase(name)
-      case _ => idToStr(id)
+    if (exprType.isInstanceOf[BytesTerminatedType] && expr.isInstanceOf[InternalName]) {
+      val alByte = translator.allocateLocalVar()
+      out.puts(s"byte${alByte}Procesed, err := $exprProcessed.Write()")
+      translator.returnRes = None
+      translator.outAddErrCheck()
+      exprProcessed = s"byte${alByte}Procesed"
     }
 
-  /**
-    * Determine Go data type corresponding to a KS data type.
-    *
-    * @param attrType KS data type
-    * @return Go data type
-    */
+    val stmt = dt match {
+      case t: ReadableType =>
+        s"$io.Write${Utils.capitalize(t.apiCall(defEndian))}(${if (exprProcessed.contains("(") && exprProcessed.contains(")")) exprProcessed else s"${kaitaiType2NativeType(dt)}($exprProcessed)"})"
+      case BitsType1(bitEndian) =>
+        s"$io.WriteU1(uint8(${translator.boolToInt(expr)}))"
+      case BitsType(width: Int, bitEndian) =>
+        s"$io.WriteBitsInt${Utils.upperCamelCase(bitEndian.toSuffix)}($width, $exprProcessed)"
+      case _: BytesType =>
+        s"$io.WriteBytes($exprProcessed)"
+    }
+    out.puts(s"err = $stmt")
+    translator.outAddErrCheck()
+  }
+
+  override def attrBytesLimitWrite(io: String, expr: Ast.expr, size: String, term: Int, padRight: Int): Unit = {
+    out.puts(s"$io.WriteBytesLimit(${expression(expr)}, int64($size), $term, $padRight)")
+  }
+
+  override def attrUserTypeInstreamWrite(io: String, valueExpr: Ast.expr, t: DataType, exprType: DataType): Unit = {
+    var changedExpr = valueExpr
+    var tmpVarName = ""
+    if (inSwitchCaseHandler && (kaitaiType2NativeType(translator.detectType(valueExpr)) == "kaitai.AnyTypeInterface" || kaitaiType2NativeType(translator.detectType(valueExpr)) == "interface{}")) {
+      val (changedActual, tmpName) = translator.interfaceTypeOfSwitchCaseInExpr(valueExpr, Option(t), (dt) => {
+        kaitaiType2NativeType(dt)
+      })
+      changedExpr = changedActual
+      tmpVarName = tmpName
+      if (tmpVarName == "") {
+        tmpVarName = expression(valueExpr)
+      }
+    } else {
+      tmpVarName = expression(valueExpr)
+    }
+    out.puts(s"err = $tmpVarName.${if (translator.detectType(valueExpr) == AnyType && !tmpVarName.contains("tmp")) s"(${kaitaiType2NativeType(t)})." else ""}WriteSeq($io)")
+    translator.outAddErrCheck()
+  }
+
+  override def exprStreamToByteArray(ioFixed: String): String = {
+    out.puts(s"fixedByteArray, err := $ioFixed.ToByteArray()")
+    s"fixedByteArray"
+  }
+
+  override def attrUnprocess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec, dt: BytesType, exprTypeOpt: Option[DataType]): Unit = {
+    val exprType = exprTypeOpt.getOrElse(dt)
+    val srcExprRaw = varSrc match {
+      // use `_raw_items[_raw_items.size - 1]`
+      case _: RawIdentifier => getRawIdExpr(varSrc, rep)
+      // but `items[_index]`
+      case _ => expression(itemExpr(varSrc, rep))
+    }
+    val srcExpr = castIfNeeded(srcExprRaw, exprType, dt)
+
+    val expr = proc match {
+      case ProcessXor(xorValue) =>
+        val argStr = if (inSubIOWriteBackHandler) "processXorArg" else expression(xorValue)
+        val xorValueStr = translator.detectType(xorValue) match {
+          case _: IntType => s"kaitai.ProcessXOR($srcExpr, []byte{$argStr})"
+          case _ => s"kaitai.ProcessXOR($srcExpr, $argStr)"
+        }
+        translator.returnRes = None
+        xorValueStr
+      case ProcessZlib =>
+        translator.returnRes = Some("err")
+        s"kaitai.UnprocessZlib($srcExpr)"
+      case ProcessRotate(isLeft, rotValue) =>
+        val argStr = if (inSubIOWriteBackHandler) "processRotateArg" else expression(rotValue)
+        val expr = if (!isLeft) {
+          argStr
+        } else {
+          s"8 - ($argStr)"
+        }
+        translator.returnRes = None
+        s"kaitai.ProcessRotateLeft($srcExpr, int($expr))"
+      case ProcessCustom(name, args) =>
+        val namespace = name.init.mkString(".")
+        var procClass = (namespace + type2class(name.last)).replace(".", "").capitalize
+        val procName = s"process${idToStr(varSrc)}"
+        if (!inSubIOWriteBackHandler) {
+          out.puts(s"$procName := New$procClass(${args.map(expression).mkString(", ")})")
+        }
+        translator.returnRes = Some("err")
+        if (procStack.get(procClass) == None) {
+          procStack = procStack + ((procClass, newProcConstructor(procClass, args)))
+        }
+        s"$procName.Encode($srcExpr)"
+    }
+
+    handleAssignment(varDest, expr, rep, isRaw = false)
+  }
+
+  def newProcConstructor(procName: String, args: Seq[Ast.expr]) = {
+    () => {
+      out.puts(
+        s"""
+           |type $procName struct {\n${args.map(f => s"\targ${args.indexOf(f)} ${kaitaiType2NativeType(translator.detectType(f))}").mkString("\n")}\n}
+           |
+           |func New$procName(${args.map(f => s"arg${args.indexOf(f)} ${kaitaiType2NativeType(translator.detectType(f))}").mkString(", ")}) *$procName {
+           |    return &$procName{${args.map(f => s"arg${args.indexOf(f)}").mkString(", ")}}
+           |}
+           |
+           |func (this *$procName) Encode(buf []byte) (b []byte, err error) {
+           |    return
+           |}""".stripMargin)
+
+    }
+  }
+
+
+  override def attrUnprocessPrepareBeforeSubIOHandler(proc: ProcessExpr, varSrc: Identifier): Unit = {
+    proc match {
+      case ProcessXor(xorValue) =>
+        val dataType = translator.detectType(xorValue)
+        out.puts(s"var processXorArg uint8 = ${expression(xorValue)}")
+      case ProcessRotate(_, rotValue) =>
+        val dataType = translator.detectType(rotValue)
+        out.puts(s"processRotateArg := ${expression(rotValue)}")
+      case ProcessZlib => // no process arguments
+      case ProcessCustom(name, args) =>
+        val namespace = name.init.mkString(".")
+        val procClass = namespace +
+          (if (namespace.nonEmpty) "." else "") +
+          type2class(name.last)
+        val procName = s"Process${idToStr(varSrc)}"
+        out.puts(s"$procName := New$procClass(${args.map(expression).mkString(", ")})")
+    }
+  }
+
+  override def condIfIsEofHeader(io: String, wantedIsEof: Boolean): Unit = {
+    val eofExpr = s"isEOF, err := $io.EOF()"
+    val eofVal = "isEOF"
+    val ifExpr = if (!wantedIsEof) {
+      s"$eofVal"
+    } else {
+      s"!$eofVal"
+    }
+
+    out.puts(eofExpr)
+    translator.outAddErrCheck()
+    out.puts(s"if $ifExpr {")
+    out.inc
+  }
+
+  override def condIfIsEofFooter: Unit = universalFooter
+
+  override def attrBasicCheck(checkExpr: Ast.expr, actual: Ast.expr, expected: Ast.expr, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if ${expression(checkExpr)} {")
+    out.inc
+
+    out.puts(s"return kaitai.NewConsistencyError($msgStr, ${expression(actual)}, ${expression(expected)})")
+    out.dec
+    out.puts("}")
+  }
+
+  override def attrIsEofCheck(io: String, expectedIsEof: Boolean, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    val eofExpr = s"isEOF, err := $io.EOF()"
+    val eofVal = "isEOF"
+    val ifExpr = if (expectedIsEof) {
+      s"!$eofVal"
+    } else {
+      s"$eofVal"
+    }
+
+    out.puts(eofExpr)
+    translator.outAddErrCheck()
+    out.puts(s"if $ifExpr {")
+    out.inc
+    out.puts(s"return kaitai.NewConsistencyError($msgStr, ${exprIORemainingSize(io)}, 0)")
+    out.dec
+    out.puts("}")
+  }
+
+  override def attrObjectsEqualCheck(actual: Ast.expr, expected: Ast.expr, msg: String): Unit = {
+    importList.add("reflect")
+    val tmpVarName = expression(actual)
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if !reflect.DeepEqual($tmpVarName, ${expression(expected)}) {")
+    out.inc
+    out.puts(s"return kaitai.NewConsistencyError($msgStr, $tmpVarName, ${expression(expected)})")
+    out.dec
+    out.puts("}")
+  }
+
+  override def attrParentParamCheck(actualParentExpr: Ast.expr, ut: UserType, shouldDependOnIo: Option[Boolean], msg: String): Unit = {
+    if (ut.isOpaque)
+      return
+    val (expectedParent, dependsOnIo) = ut.forcedParent match {
+      case Some(USER_TYPE_NO_PARENT) => ("nil", false)
+      case Some(fp) =>
+        (expression(fp), userExprDependsOnIo(fp))
+      case None => ("this", false)
+    }
+    if (shouldDependOnIo.map(shouldDepend => dependsOnIo != shouldDepend).getOrElse(false))
+      return
+
+    val tmpVarName = expression(actualParentExpr)
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if !reflect.DeepEqual($tmpVarName, $expectedParent) {")
+    out.inc
+    out.puts(s"return kaitai.NewConsistencyError($msgStr, $tmpVarName, $expectedParent)")
+    out.dec
+    out.puts("}")
+  }
+
+  override def attrBytesTypeParse(
+    id: Identifier,
+    dataType: BytesType,
+    io: String,
+    rep: RepeatSpec,
+    isRaw: Boolean
+  ): Unit = {
+    val rawId = dataType.process match {
+      case None => id
+      case Some(_) => RawIdentifier(id)
+    }
+    val expr = parseExprBytes(translator.outVarCheckRes(parseExpr(dataType, io, None)), dataType)
+    handleAssignment(rawId, expr, rep, isRaw)
+    dataType.process.foreach((proc) => attrProcess(proc, rawId, id, rep))
+  }
+
+  def kstructNameFull: String = {
+    kstructName.format((config.autoRead, config.readWrite) match{
+      case (_, true) => ""
+      case (_, false) => ""
+    })
+  }
+
   def kaitaiType2NativeType(attrType: DataType): String = {
     attrType match {
       case Int1Type(false) => "uint8"
@@ -626,11 +1325,22 @@ object GoCompiler extends LanguageCompilerStatic
       case CalcIntType => "int"
       case CalcFloatType => "float64"
 
+      // Some specual cases
+      case sbt: StrFromBytesType => {
+        sbt.bytes match {
+          case _: BytesTerminatedType =>  s"*${kTerminatedType.format("String")}"
+          case _ => "string"
+        }
+      }
+      case _: BytesTerminatedType => s"*${kTerminatedType.format("Bytes")}"
+      // Normal cases
       case _: StrType => "string"
       case _: BytesType => "[]byte"
 
-      case AnyType => "interface{}"
-      case KaitaiStructType | CalcKaitaiStructType(_) => kstructName
+      case AnyType => "kaitai.AnyTypeInterface"
+      case CalcAnyType => "interface{}"
+
+      case KaitaiStructType | CalcKaitaiStructType(_) => "*" + kstructNameFull
       case KaitaiStreamType | OwnedKaitaiStreamType => "*" + kstreamName
 
       case t: UserType => "*" + types2class(t.classSpec match {
@@ -644,6 +1354,45 @@ object GoCompiler extends LanguageCompilerStatic
       case st: SwitchType => kaitaiType2NativeType(st.combinedType)
     }
   }
+}
+
+object GoCompiler extends LanguageCompilerStatic
+  with UpperCamelCaseClasses
+  with StreamStructNames
+  with ExceptionNames {
+
+  override def getCompiler(
+    tp: ClassTypeProvider,
+    config: RuntimeConfig
+  ): LanguageCompiler = new GoCompiler(tp, config)
+
+  def idToStr(id: Identifier): String =
+    id match {
+      case SpecialIdentifier(name) => name
+      case NamedIdentifier(name) => Utils.upperCamelCase(name)
+      case NumberedIdentifier(idx) => s"_${NumberedIdentifier.TEMPLATE}$idx"
+      case InstanceIdentifier(name) => Utils.lowerCamelCase(name)
+      case RawIdentifier(innerId) => s"_raw_${idToStr(innerId)}"
+      case IoStorageIdentifier(innerId) => s"_io_${idToStr(innerId)}"
+      case OuterSizeIdentifier(innerId) => s"${idToStr(innerId)}_OuterSize"
+      case InnerSizeIdentifier(innerId) => s"${idToStr(innerId)}_InnerSize"
+    }
+
+  def publicMemberName(id: Identifier): String =
+    id match {
+      case IoIdentifier => "_IO"
+      case RootIdentifier => "_Root"
+      case ParentIdentifier => "_Parent"
+      case InstanceIdentifier(name) => Utils.lowerCamelCase(name)
+      case _ => idToStr(id)
+    }
+
+  /**
+    * Determine Go data type corresponding to a KS data type.
+    *
+    * @param attrType KS data type
+    * @return Go data type
+    */
 
   def types2class(names: List[String]): String = names.map(x => type2class(x)).mkString("_")
 
@@ -656,8 +1405,10 @@ object GoCompiler extends LanguageCompilerStatic
   def enumToStr(typeName: List[String], enumName: String): String =
     types2class(typeName) + "__" + type2class(enumName)
 
+  def kTerminatedType: String = "kaitai.%sTerminatedType"
+
   override def kstreamName: String = "kaitai.Stream"
-  override def kstructName: String = "interface{}"
+  override def kstructName: String = "kaitai.%sStream"
   override def ksErrorName(err: KSError): String = err match {
     case ConversionError => "strconv.NumError"
     case _ => s"kaitai.${err.name}"
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/JavaCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/JavaCompiler.scala
index 231b4aeab..f52dc1612 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/JavaCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/JavaCompiler.scala
@@ -15,15 +15,17 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with UpperCamelCaseClasses
     with ObjectOrientedLanguage
     with EveryReadIsExpression
+    with FetchInstances
+    with EveryWriteIsExpression
+    with GenericChecks
     with UniversalFooter
     with UniversalDoc
     with AllocateIOLocalVar
-    with FixedContentsUsingArrayByteLiteral
     with SwitchIfOps
     with NoNeedForFullClassPath {
   import JavaCompiler._
 
-  val translator = new JavaTranslator(typeProvider, importList)
+  val translator = new JavaTranslator(typeProvider, importList, config)
 
   // Preprocess fromFileClass and make import
   val fromFileClass = {
@@ -38,6 +40,10 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     }
   }
 
+  /** See [[subIOWriteBackHeader]] => the code generated when `true` will be inside the definition
+   * of the "writeBackHandler" callback function. */
+  private var inSubIOWriteBackHandler = false
+
   override def universalFooter: Unit = {
     out.dec
     out.puts("}")
@@ -72,7 +78,10 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
       ""
     }
 
-    out.puts(s"public ${staticStr}class ${type2class(name)} extends $kstructName {")
+    out.puts(
+      s"public ${staticStr}class ${type2class(name)} " +
+      s"extends $kstructNameFull {"
+    )
     out.inc
 
     if (config.readStoresPos) {
@@ -131,6 +140,14 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
       val paramsRelay = Utils.join(params.map((p) => paramName(p.id)), ", ", ", ", "")
 
+      if (config.readWrite) {
+        out.puts(s"public ${type2class(name)}(${paramsArg.stripPrefix(", ")}) {")
+        out.inc
+        out.puts(s"this(null, null, null$paramsRelay);")
+        out.dec
+        out.puts("}")
+      }
+
       out.puts
       out.puts(s"public ${type2class(name)}($kstreamName _io$paramsArg) {")
       out.inc
@@ -181,28 +198,100 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
+  override def runWriteCalc(): Unit = {
+    out.puts
+    out.puts("if (_is_le == null) {")
+    out.inc
+    out.puts(s"throw new $kstreamName.UndecidedEndiannessError();")
+    out.dec
+    out.puts("} else if (_is_le) {")
+    out.inc
+    out.puts("_write_SeqLE();")
+    out.dec
+    out.puts("} else {")
+    out.inc
+    out.puts("_write_SeqBE();")
+    out.dec
+    out.puts("}")
+  }
+
   override def readHeader(endian: Option[FixedEndian], isEmpty: Boolean) = {
-    val readAccessAndType = if (!config.autoRead) {
-      "public"
-    } else {
-      "private"
+    endian match {
+      case Some(e) =>
+        out.puts(s"private void _read${Utils.upperUnderscoreCase(e.toSuffix)}() {")
+      case None =>
+        out.puts(s"${if (!config.autoRead) "public" else "private"} void _read() {")
     }
-    val suffix = endian match {
-      case Some(e) => Utils.upperUnderscoreCase(e.toSuffix)
-      case None => ""
+    out.inc
+  }
+
+  override def fetchInstancesHeader(): Unit = {
+    out.puts
+    out.puts("public void _fetchInstances() {")
+    out.inc
+  }
+
+  override def fetchInstancesFooter: Unit = universalFooter
+
+  override def attrInvokeFetchInstances(baseExpr: Ast.expr, exprType: DataType, dataType: DataType): Unit = {
+    val expr = castIfNeeded(expression(baseExpr), exprType, dataType)
+    out.puts(s"$expr._fetchInstances();")
+  }
+
+  override def attrInvokeInstance(instName: InstanceIdentifier): Unit = {
+    out.puts(s"${publicMemberName(instName)}();")
+  }
+
+  override def writeHeader(endian: Option[FixedEndian], isEmpty: Boolean): Unit = {
+    out.puts
+    endian match {
+      case Some(e) =>
+        out.puts(s"private void _write_Seq${Utils.upperUnderscoreCase(e.toSuffix)}() {")
+      case None =>
+        out.puts("public void _write_Seq() {")
     }
-    out.puts(s"$readAccessAndType void _read$suffix() {")
     out.inc
   }
 
-  override def readFooter(): Unit = universalFooter
+  override def checkHeader(): Unit = {
+    out.puts
+    out.puts("public void _check() {")
+    out.inc
+  }
+
+  override def writeInstanceHeader(instName: InstanceIdentifier): Unit = {
+    out.puts
+    out.puts(s"public void _write${idToSetterStr(instName)}() {")
+    out.inc
+    instanceClearWriteFlag(instName)
+  }
+
+  override def checkInstanceHeader(instName: InstanceIdentifier): Unit = {
+    out.puts
+    out.puts(s"public void _check${idToSetterStr(instName)}() {")
+    out.inc
+  }
 
   override def attributeDeclaration(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
     out.puts(s"private ${kaitaiType2JavaType(attrType, isNullable)} ${idToStr(attrName)};")
   }
 
   override def attributeReader(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
-    out.puts(s"public ${kaitaiType2JavaType(attrType, isNullable)} ${idToStr(attrName)}() { return ${idToStr(attrName)}; }")
+    val javaType = kaitaiType2JavaType(attrType, isNullable)
+    val name = idToStr(attrName)
+
+    out.puts(s"public $javaType $name() { return $name; }")
+  }
+
+  override def attributeSetter(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
+    val javaType = kaitaiType2JavaType(attrType, isNullable)
+    val name = idToStr(attrName)
+
+    out.puts(s"public void set${idToSetterStr(attrName)}($javaType _v) { $name = _v; }")
+  }
+
+  override def attrSetProperty(base: Ast.expr, propName: Identifier, value: String): Unit = {
+    out.puts(s"${expression(base)}.set${idToSetterStr(propName)}($value);")
   }
 
   override def universalDoc(doc: DocSpec): Unit = {
@@ -233,10 +322,6 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit = {
-    out.puts(s"${privateMemberName(attrName)} = $normalIO.ensureFixedContents($contents);")
-  }
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -268,6 +353,67 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     handleAssignment(varDest, expr, rep, false)
   }
 
+  override def attrUnprocess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec, dataType: BytesType, exprTypeOpt: Option[DataType]): Unit = {
+    val exprType = exprTypeOpt.getOrElse(dataType)
+    val srcExprRaw = varSrc match {
+      // use `_raw_items[_raw_items.size - 1]`
+      case _: RawIdentifier => getRawIdExpr(varSrc, rep)
+      // but `items[_index]`
+      case _ => expression(itemExpr(varSrc, rep))
+    }
+    val srcExpr = castIfNeeded(srcExprRaw, exprType, dataType)
+
+    val expr = proc match {
+      case ProcessXor(xorValue) =>
+        val argStr = if (inSubIOWriteBackHandler) "_processXorArg" else expression(xorValue)
+        val xorValueStr = translator.detectType(xorValue) match {
+          case _: IntType => castIfNeeded(argStr, AnyType, Int1Type(true))
+          case _ => argStr
+        }
+        s"$kstreamName.processXor($srcExpr, $xorValueStr)"
+      case ProcessZlib =>
+        s"$kstreamName.unprocessZlib($srcExpr)"
+      case ProcessRotate(isLeft, rotValue) =>
+        val argStr = if (inSubIOWriteBackHandler) "_processRotateArg" else expression(rotValue)
+        val expr = if (!isLeft) {
+          argStr
+        } else {
+          s"8 - ($argStr)"
+        }
+        s"$kstreamName.processRotateLeft($srcExpr, $expr, 1)"
+      case ProcessCustom(name, args) =>
+        val namespace = name.init.mkString(".")
+        val procClass = namespace +
+          (if (namespace.nonEmpty) "." else "") +
+          type2class(name.last)
+        val procName = s"_process_${idToStr(varSrc)}"
+        if (!inSubIOWriteBackHandler) {
+          out.puts(s"$procClass $procName = new $procClass(${args.map(expression).mkString(", ")});")
+        }
+        s"$procName.encode($srcExpr)"
+    }
+    handleAssignment(varDest, expr, rep, false)
+  }
+
+  override def attrUnprocessPrepareBeforeSubIOHandler(proc: ProcessExpr, varSrc: Identifier): Unit = {
+    proc match {
+      case ProcessXor(xorValue) =>
+        val dataType = translator.detectType(xorValue)
+        out.puts(s"final ${kaitaiType2JavaType(dataType)} _processXorArg = ${expression(xorValue)};")
+      case ProcessRotate(_, rotValue) =>
+        val dataType = translator.detectType(rotValue)
+        out.puts(s"final ${kaitaiType2JavaType(dataType)} _processRotateArg = ${expression(rotValue)};")
+      case ProcessZlib => // no process arguments
+      case ProcessCustom(name, args) =>
+        val namespace = name.init.mkString(".")
+        val procClass = namespace +
+          (if (namespace.nonEmpty) "." else "") +
+          type2class(name.last)
+        val procName = s"_process_${idToStr(varSrc)}"
+        out.puts(s"final $procClass $procName = new $procClass(${args.map(expression).mkString(", ")});")
+    }
+  }
+
   override def allocateIO(varName: Identifier, rep: RepeatSpec): String = {
     val ioName = idToStr(IoStorageIdentifier(varName))
 
@@ -281,8 +427,47 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     ioName
   }
 
+  override def allocateIOFixed(varName: Identifier, size: String): String = {
+    val ioName = idToStr(IoStorageIdentifier(varName))
+
+    out.puts(s"final $kstreamName $ioName = new ByteBufferKaitaiStream($size);")
+    ioName
+  }
+
+  override def exprIORemainingSize(io: String): String =
+    s"$io.size() - $io.pos()"
+
+  override def allocateIOGrowing(varName: Identifier): String =
+    allocateIOFixed(varName, "100000") // FIXME to use real growing buffer
+
+  override def subIOWriteBackHeader(subIO: String, process: Option[ProcessExpr]): String = {
+    val parentIoName = "parent"
+    out.puts(s"final ${type2class(typeProvider.nowClass.name.last)} _this = this;")
+    out.puts(s"$subIO.setWriteBackHandler(new $kstreamName.WriteBackHandler(_pos2) {")
+    out.inc
+    out.puts("@Override")
+    out.puts(s"protected void write($kstreamName $parentIoName) {")
+    out.inc
+
+    inSubIOWriteBackHandler = true
+
+    parentIoName
+  }
+
+  override def subIOWriteBackFooter(subIO: String): Unit = {
+    inSubIOWriteBackHandler = false
+
+    out.dec
+    out.puts("}")
+    out.dec
+    out.puts("});")
+  }
+
+  override def addChildIO(io: String, childIO: String): Unit =
+    out.puts(s"$io.addChildStream($childIO);")
+
   def getRawIdExpr(varName: Identifier, rep: RepeatSpec): String = {
-    val memberName = idToStr(varName)
+    val memberName = privateMemberName(varName)
     rep match {
       case NoRepeat => memberName
       case _ => s"$memberName.get($memberName.size() - 1)"
@@ -297,14 +482,22 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def pushPos(io: String): Unit =
     out.puts(s"long _pos = $io.pos();")
 
+  override def pushPosForSubIOWriteBackHandler(io: String): Unit =
+    out.puts(s"long _pos2 = $io.pos();")
+
   override def seek(io: String, pos: Ast.expr): Unit =
     out.puts(s"$io.seek(${expression(pos)});")
 
+  override def seekRelative(io: String, relPos: String): Unit =
+    out.puts(s"$io.seek($io.pos() + ($relPos));")
+
   override def popPos(io: String): Unit =
     out.puts(s"$io.seek(_pos);")
 
-  override def alignToByte(io: String): Unit =
-    out.puts(s"$io.alignToByte();")
+  // NOTE: the compiler does not need to output alignToByte() calls for Java anymore,
+  // since the byte alignment is handled by the runtime library since commit
+  // https://github.com/kaitai-io/kaitai_struct_java_runtime/commit/1bc75aa91199588a1cb12a5a1c672b80b66619ac
+  override def alignToByte(io: String): Unit = {}
 
   override def attrDebugStart(attrId: Identifier, attrType: DataType, ios: Option[String], rep: RepeatSpec): Unit = {
     ios.foreach { (io) =>
@@ -384,13 +577,19 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     importList.add("java.util.ArrayList")
   }
 
+  // used for all repetitions in _check()
+  override def condRepeatCommonHeader(id: Identifier, io: String, dataType: DataType): Unit = {
+    out.puts(s"for (int i = 0; i < ${privateMemberName(id)}.size(); i++) {")
+    out.inc
+  }
+
   override def handleAssignmentRepeatExpr(id: Identifier, expr: String): Unit =
     handleAssignmentRepeatEos(id, expr)
 
   override def condRepeatUntilHeader(id: Identifier, io: String, dataType: DataType, untilExpr: expr): Unit = {
     out.puts("{")
     out.inc
-    out.puts(s"${kaitaiType2JavaType(dataType)} ${translator.doName("_")};")
+    out.puts(s"${kaitaiType2JavaType(dataType)} ${translator.doName(Identifier.ITERATOR)};")
     out.puts("int i = 0;")
     out.puts("do {")
     out.inc
@@ -462,11 +661,7 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
         s"new ${types2class(t.name)}($io$addArgs$addParams)"
     }
 
-    if (assignType != dataType) {
-      s"(${kaitaiType2JavaType(assignType)}) ($expr)"
-    } else {
-      expr
-    }
+    castIfNeeded(expr, dataType, assignType)
   }
 
   override def createSubstreamFixedSize(id: Identifier, blt: BytesLimitType, io: String, rep: RepeatSpec, defEndian: Option[FixedEndian]): String = {
@@ -493,8 +688,9 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
   override def bytesPadTermExpr(expr0: String, padRight: Option[Int], terminator: Option[Int], include: Boolean) = {
     val expr1 = padRight match {
-      case Some(padByte) => s"$kstreamName.bytesStripRight($expr0, (byte) $padByte)"
-      case None => expr0
+      case Some(padByte) if terminator.map(term => padByte != term).getOrElse(true) =>
+        s"$kstreamName.bytesStripRight($expr0, (byte) $padByte)"
+      case _ => expr0
     }
     val expr2 = terminator match {
       case Some(term) => s"$kstreamName.bytesTerminate($expr1, (byte) $term, $include)"
@@ -504,11 +700,7 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   }
 
   override def userTypeDebugRead(id: String, dataType: DataType, assignType: DataType): Unit = {
-    val expr = if (assignType != dataType) {
-      s"((${kaitaiType2JavaType(dataType)}) ($id))"
-    } else {
-      id
-    }
+    val expr = castIfNeeded(id, assignType, dataType)
     out.puts(s"$expr._read();")
   }
 
@@ -653,6 +845,23 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"private ${kaitaiType2JavaTypeBoxed(attrType)} ${idToStr(attrName)};")
   }
 
+  override def instanceWriteFlagDeclaration(attrName: InstanceIdentifier): Unit = {
+    out.puts(s"private boolean _write${idToSetterStr(attrName)} = false;")
+    out.puts(s"private boolean _toWrite${idToSetterStr(attrName)} = true;")
+  }
+
+  override def instanceSetWriteFlag(instName: InstanceIdentifier): Unit = {
+    out.puts(s"_write${idToSetterStr(instName)} = _toWrite${idToSetterStr(instName)};")
+  }
+
+  override def instanceClearWriteFlag(instName: InstanceIdentifier): Unit = {
+    out.puts(s"_write${idToSetterStr(instName)} = false;")
+  }
+
+  override def instanceToWriteSetter(instName: InstanceIdentifier): Unit = {
+    out.puts(s"public void set${idToSetterStr(instName)}_ToWrite(boolean _v) { _toWrite${idToSetterStr(instName)} = _v; }")
+  }
+
   override def instanceHeader(className: String, instName: InstanceIdentifier, dataType: DataType, isNullable: Boolean): Unit = {
     out.puts(s"public ${kaitaiType2JavaTypeBoxed(dataType)} ${idToStr(instName)}() {")
     out.inc
@@ -665,6 +874,13 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.dec
   }
 
+  override def instanceCheckWriteFlagAndWrite(instName: InstanceIdentifier): Unit = {
+    out.puts(s"if (_write${idToSetterStr(instName)})")
+    out.inc
+    out.puts(s"_write${idToSetterStr(instName)}();")
+    out.dec
+  }
+
   override def instanceReturn(instName: InstanceIdentifier, attrType: DataType): Unit = {
     out.puts(s"return ${privateMemberName(instName)};")
   }
@@ -673,19 +889,22 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     val primType = kaitaiType2JavaTypePrim(dataType)
     val boxedType = kaitaiType2JavaTypeBoxed(dataType)
 
-    if (primType != boxedType) {
-      // Special trick to achieve both implicit type conversion + boxing.
-      // Unfortunately, Java can't do both in one assignment, i.e. this would fail:
+    if (dataType.isInstanceOf[NumericType]) {
+      // Special trick to achieve both type conversion + boxing.
+      // Unfortunately, Java can't do both by itself, i.e. this would fail:
       //
       // Double c = 1.0f + 1;
 
-      out.puts(s"$primType _tmp = ($primType) (${expression(value)});")
-      out.puts(s"${privateMemberName(instName)} = _tmp;")
+      out.puts(s"${privateMemberName(instName)} = ${translator.doCast(value, dataType)};")
     } else {
       out.puts(s"${privateMemberName(instName)} = ${expression(value)};")
     }
   }
 
+  override def instanceInvalidate(instName: InstanceIdentifier): Unit = {
+    out.puts(s"public void _invalidate${idToSetterStr(instName)}() { ${privateMemberName(instName)} = null; }")
+  }
+
   override def enumDeclaration(curClass: String, enumName: String, enumColl: Seq[(Long, String)]): Unit = {
     val enumClass = type2class(enumName)
 
@@ -724,6 +943,13 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     importList.add("java.util.HashMap")
   }
 
+  override def internalEnumIntType(basedOn: IntType): DataType = {
+    basedOn match {
+      case IntMultiType(signed, _, endian) => IntMultiType(signed, Width8, endian)
+      case _ => IntMultiType(true, Width8, None)
+    }
+  }
+
   override def debugClassSequence(seq: List[AttrSpec]) = {
     val seqStr = seq.map((attr) => "\"" + idToStr(attr.id) + "\"").mkString(", ")
     out.puts(s"public static String[] _seqFields = new String[] { $seqStr };")
@@ -739,13 +965,139 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
+  override def attrPrimitiveWrite(
+    io: String,
+    valueExpr: Ast.expr,
+    dataType: DataType,
+    defEndian: Option[FixedEndian],
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    val exprType = exprTypeOpt.getOrElse(dataType)
+    val exprRaw = expression(valueExpr)
+    val expr = castIfNeeded(exprRaw, exprType, dataType)
+
+    val stmt = dataType match {
+      case t: ReadableType =>
+        s"$io.write${Utils.capitalize(t.apiCall(defEndian))}($expr)"
+      case BitsType1(bitEndian) =>
+        s"$io.writeBitsInt${Utils.upperCamelCase(bitEndian.toSuffix)}(1, ${translator.boolToInt(valueExpr)})"
+      case BitsType(width: Int, bitEndian) =>
+        s"$io.writeBitsInt${Utils.upperCamelCase(bitEndian.toSuffix)}($width, $expr)"
+      case _: BytesType =>
+        s"$io.writeBytes($expr)"
+    }
+    out.puts(stmt + ";")
+  }
+
+  override def attrBytesLimitWrite(io: String, expr: Ast.expr, size: String, term: Int, padRight: Int): Unit =
+    out.puts(s"$io.writeBytesLimit(${expression(expr)}, $size, (byte) $term, (byte) $padRight);")
+
+  override def attrUserTypeInstreamWrite(io: String, valueExpr: Ast.expr, dataType: DataType, exprType: DataType) = {
+    val exprRaw = expression(valueExpr)
+    val expr = castIfNeeded(exprRaw, exprType, dataType)
+    out.puts(s"$expr._write_Seq($io);")
+  }
+
+  override def exprStreamToByteArray(io: String): String =
+    s"$io.toByteArray()"
+
+  override def attrBasicCheck(checkExpr: Ast.expr, actual: Ast.expr, expected: Ast.expr, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if (${expression(checkExpr)})")
+    out.inc
+    out.puts(s"throw new ConsistencyError($msgStr, ${expression(actual)}, ${expression(expected)});")
+    out.dec
+
+    importList.add("io.kaitai.struct.ConsistencyError")
+  }
+
+  override def attrObjectsEqualCheck(actual: Ast.expr, expected: Ast.expr, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if (!Objects.equals(${expression(actual)}, ${expression(expected)}))")
+    out.inc
+    out.puts(s"throw new ConsistencyError($msgStr, ${expression(actual)}, ${expression(expected)});")
+    out.dec
+
+    importList.add("java.util.Objects")
+    importList.add("io.kaitai.struct.ConsistencyError")
+  }
+
+  override def attrParentParamCheck(actualParentExpr: Ast.expr, ut: UserType, shouldDependOnIo: Option[Boolean], msg: String): Unit = {
+    if (ut.isOpaque)
+      return
+    /** @note Must be kept in sync with [[JavaCompiler.parseExpr]] */
+    val (expectedParent, dependsOnIo) = ut.forcedParent match {
+      case Some(USER_TYPE_NO_PARENT) => ("null", false)
+      case Some(fp) =>
+        (expression(fp), userExprDependsOnIo(fp))
+      case None => ("this", false)
+    }
+    if (shouldDependOnIo.map(shouldDepend => dependsOnIo != shouldDepend).getOrElse(false))
+      return
+
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if (!Objects.equals(${expression(actualParentExpr)}, $expectedParent))")
+    out.inc
+    out.puts(s"throw new ConsistencyError($msgStr, ${expression(actualParentExpr)}, $expectedParent);")
+    out.dec
+
+    importList.add("java.util.Objects")
+    importList.add("io.kaitai.struct.ConsistencyError")
+  }
+
+  override def attrIsEofCheck(io: String, expectedIsEof: Boolean, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    val eofExpr = s"$io.isEof()"
+    val ifExpr = if (expectedIsEof) {
+      s"!($eofExpr)"
+    } else {
+      eofExpr
+    }
+    out.puts(s"if ($ifExpr)")
+    out.inc
+    out.puts(s"throw new ConsistencyError($msgStr, ${exprIORemainingSize(io)}, 0);")
+    out.dec
+
+    importList.add("io.kaitai.struct.ConsistencyError")
+  }
+
+  override def condIfIsEofHeader(io: String, wantedIsEof: Boolean): Unit = {
+    val eofExpr = s"$io.isEof()"
+    val ifExpr = if (!wantedIsEof) {
+      s"!($eofExpr)"
+    } else {
+      eofExpr
+    }
+
+    out.puts(s"if ($ifExpr) {")
+    out.inc
+  }
+
+  override def condIfIsEofFooter: Unit = universalFooter
+
   def value2Const(s: String) = Utils.upperUnderscoreCase(s)
 
   override def idToStr(id: Identifier): String = JavaCompiler.idToStr(id)
 
   override def publicMemberName(id: Identifier) = JavaCompiler.publicMemberName(id)
 
-  override def privateMemberName(id: Identifier): String = s"this.${idToStr(id)}"
+  def idToSetterStr(id: Identifier): String = {
+    id match {
+      case SpecialIdentifier(name) => name
+      case NamedIdentifier(name) => Utils.upperCamelCase(name)
+      case NumberedIdentifier(idx) => s"_${NumberedIdentifier.TEMPLATE}$idx"
+      case InstanceIdentifier(name) => Utils.upperCamelCase(name)
+      case RawIdentifier(innerId) => "_raw_" + idToSetterStr(innerId)
+      case OuterSizeIdentifier(innerId) => s"${idToSetterStr(innerId)}_OuterSize"
+      case InnerSizeIdentifier(innerId) => s"${idToSetterStr(innerId)}_InnerSize"
+    }
+  }
+
+  override def privateMemberName(id: Identifier): String = s"${if (inSubIOWriteBackHandler) "_" else ""}this.${idToStr(id)}"
 
   override def localTemporaryName(id: Identifier): String = s"_t_${idToStr(id)}"
 
@@ -756,40 +1108,31 @@ class JavaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   }
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "null",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     out.puts(s"if (!(${translator.translate(checkExpr)})) {")
     out.inc
-    out.puts(s"throw new ${ksErrorName(err)}($errArgsStr);")
+    out.puts(s"throw new ${ksErrorName(err)}(${errArgsStr.mkString(", ")});")
     out.dec
     out.puts("}")
   }
-}
 
-object JavaCompiler extends LanguageCompilerStatic
-  with UpperCamelCaseClasses
-  with StreamStructNames {
-  override def getCompiler(
-    tp: ClassTypeProvider,
-    config: RuntimeConfig
-  ): LanguageCompiler = new JavaCompiler(tp, config)
-
-  def idToStr(id: Identifier): String =
-    id match {
-      case SpecialIdentifier(name) => name
-      case NamedIdentifier(name) => Utils.lowerCamelCase(name)
-      case NumberedIdentifier(idx) => s"_${NumberedIdentifier.TEMPLATE}$idx"
-      case InstanceIdentifier(name) => Utils.lowerCamelCase(name)
-      case RawIdentifier(innerId) => s"_raw_${idToStr(innerId)}"
-      case IoStorageIdentifier(innerId) => s"_io_${idToStr(innerId)}"
-    }
-
-  def publicMemberName(id: Identifier) = idToStr(id)
+  def kstructNameFull: String = {
+    kstructName + ((config.autoRead, config.readWrite) match {
+      case (_, true) => ".ReadWrite"
+      case (false, false) => ".ReadOnly"
+      case (true, false) => ""
+    })
+  }
 
   def kaitaiType2JavaType(attrType: DataType): String = kaitaiType2JavaTypePrim(attrType)
 
@@ -800,6 +1143,21 @@ object JavaCompiler extends LanguageCompilerStatic
       kaitaiType2JavaTypePrim(attrType)
     }
 
+  def castIfNeeded(exprRaw: String, exprType: DataType, targetType: DataType): String =
+    if (exprType != targetType) {
+      val castTypeId = kaitaiType2JavaTypePrim(targetType)
+      targetType match {
+        // Handles both unboxing + downcasting at the same time if needed
+        // (solution from https://github.com/kaitai-io/kaitai_struct_compiler/pull/149)
+        //
+        // See also https://github.com/kaitai-io/kaitai_struct_compiler/pull/212#issuecomment-731149487
+        case _: NumericType => s"((Number) ($exprRaw)).${castTypeId}Value()"
+        case _ => s"(($castTypeId) ($exprRaw))"
+      }
+    } else {
+      exprRaw
+    }
+
   /**
     * Determine Java data type corresponding to a KS data type. A "primitive" type (i.e. "int", "long", etc) will
     * be returned if possible.
@@ -833,7 +1191,7 @@ object JavaCompiler extends LanguageCompilerStatic
 
       case AnyType => "Object"
       case KaitaiStreamType | OwnedKaitaiStreamType => kstreamName
-      case KaitaiStructType | CalcKaitaiStructType(_) => kstructName
+      case KaitaiStructType | CalcKaitaiStructType(_) => kstructNameFull
 
       case t: UserType => types2class(t.name)
       case EnumType(name, _) => types2class(name)
@@ -876,8 +1234,9 @@ object JavaCompiler extends LanguageCompilerStatic
       case _: BytesType => "byte[]"
 
       case AnyType => "Object"
+      case CalcAnyType => "Object"
       case KaitaiStreamType | OwnedKaitaiStreamType => kstreamName
-      case KaitaiStructType | CalcKaitaiStructType(_) => kstructName
+      case KaitaiStructType | CalcKaitaiStructType(_) => kstructNameFull
 
       case t: UserType => types2class(t.name)
       case EnumType(name, _) => types2class(name)
@@ -888,9 +1247,34 @@ object JavaCompiler extends LanguageCompilerStatic
       case st: SwitchType => kaitaiType2JavaTypeBoxed(st.combinedType)
     }
   }
+}
+
+object JavaCompiler extends LanguageCompilerStatic
+  with UpperCamelCaseClasses
+  with StreamStructNames
+  with ExceptionNames {
+  override def getCompiler(
+    tp: ClassTypeProvider,
+    config: RuntimeConfig
+  ): LanguageCompiler = new JavaCompiler(tp, config)
+
+  def idToStr(id: Identifier): String =
+    id match {
+      case SpecialIdentifier(name) => name
+      case NamedIdentifier(name) => Utils.lowerCamelCase(name)
+      case NumberedIdentifier(idx) => s"_${NumberedIdentifier.TEMPLATE}$idx"
+      case InstanceIdentifier(name) => Utils.lowerCamelCase(name)
+      case RawIdentifier(innerId) => s"_raw_${idToStr(innerId)}"
+      case IoStorageIdentifier(innerId) => s"_io_${idToStr(innerId)}"
+      case OuterSizeIdentifier(innerId) => s"${idToStr(innerId)}_OuterSize"
+      case InnerSizeIdentifier(innerId) => s"${idToStr(innerId)}_InnerSize"
+    }
+
+  def publicMemberName(id: Identifier) = idToStr(id)
 
   def types2class(names: List[String]) = names.map(x => type2class(x)).mkString(".")
 
   override def kstreamName: String = "KaitaiStream"
   override def kstructName: String = "KaitaiStruct"
+  override def ksErrorName(err: KSError): String = s"KaitaiStream.${err.name}"
 }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/JavaScriptCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/JavaScriptCompiler.scala
index 17d6db711..31b07acfe 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/JavaScriptCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/JavaScriptCompiler.scala
@@ -17,8 +17,7 @@ class JavaScriptCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with UniversalDoc
     with AllocateIOLocalVar
     with EveryReadIsExpression
-    with SwitchIfOps
-    with FixedContentsUsingArrayByteLiteral {
+    with SwitchIfOps {
   import JavaScriptCompiler._
 
   override val translator = new JavaScriptTranslator(typeProvider)
@@ -184,11 +183,6 @@ class JavaScriptCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit = {
-    out.puts(s"${privateMemberName(attrName)} = " +
-      s"$normalIO.ensureFixedContents($contents);")
-  }
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -290,7 +284,7 @@ class JavaScriptCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   }
 
   // TODO: replace this with UniversalFooter
-  override def condIfFooter(expr: expr): Unit = {
+  override def condIfFooter: Unit = {
     out.dec
     out.puts("}")
   }
@@ -557,16 +551,20 @@ class JavaScriptCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = JavaScriptCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "null",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     out.puts(s"if (!(${translator.translate(checkExpr)})) {")
     out.inc
-    out.puts(s"throw new ${ksErrorName(err)}($errArgsStr);")
+    out.puts(s"throw new ${ksErrorName(err)}(${errArgsStr.mkString(", ")});")
     out.dec
     out.puts("}")
   }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/LuaCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/LuaCompiler.scala
index 45e9464c8..bf8065a18 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/LuaCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/LuaCompiler.scala
@@ -12,7 +12,6 @@ class LuaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   extends LanguageCompiler(typeProvider, config)
     with AllocateIOLocalVar
     with EveryReadIsExpression
-    with FixedContentsUsingArrayByteLiteral
     with ObjectOrientedLanguage
     with SingleOutputFile
     with UniversalDoc
@@ -150,14 +149,11 @@ class LuaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("end")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    out.puts(s"${privateMemberName(attrName)} = self._io:ensure_fixed_contents($contents)")
-
   override def condIfHeader(expr: Ast.expr): Unit = {
     out.puts(s"if ${expression(expr)} then")
     out.inc
   }
-  override def condIfFooter(expr: Ast.expr): Unit = {
+  override def condIfFooter: Unit = {
     out.dec
     out.puts("end")
   }
@@ -402,24 +398,21 @@ class LuaCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = LuaCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsCode = errArgs.map(translator.translate)
+    val actualStr = expression(Ast.expr.InternalName(attr.id))
     out.puts(s"if not(${translator.translate(checkExpr)}) then")
     out.inc
     val msg = err match {
       case _: ValidationNotEqualError => {
-        val (expected, actual) = (
-          errArgsCode.lift(0).getOrElse("[expected]"),
-          errArgsCode.lift(1).getOrElse("[actual]")
-        )
-        s""""not equal, expected " ..  $expected .. ", but got " .. $actual"""
+        val expectedStr = expected.get
+        s""""not equal, expected " .. $expectedStr .. ", but got " .. $actualStr"""
       }
-      case _ => "\"" + ksErrorName(err) + "\""
+      case _ => expression(Ast.expr.Str(ksErrorName(err)))
     }
     out.puts(s"error($msg)")
     out.dec
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/NimCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/NimCompiler.scala
index 565ef2700..87bc33b7d 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/NimCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/NimCompiler.scala
@@ -13,7 +13,6 @@ class NimCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with SingleOutputFile
     with EveryReadIsExpression
     with UpperCamelCaseClasses
-    with FixedContentsUsingArrayByteLiteral
     with UniversalFooter
     with AllocateIOLocalVar
     with SwitchIfOps
@@ -86,9 +85,6 @@ class NimCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     importList.add(file)
   }
   override def alignToByte(io: String): Unit = out.puts(s"alignToByte($io)")
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit = {
-    out.puts(s"this.${idToStr(attrName)} = $normalIO.ensureFixedContents($contents)")
-  }
   // def attrParse(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit = ???
   override def attrParseHybrid(leProc: () => Unit, beProc: () => Unit): Unit = {
     out.puts("if this.isLe:")
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/PHPCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/PHPCompiler.scala
index 672fcab3b..6a50fc8ce 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/PHPCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/PHPCompiler.scala
@@ -16,7 +16,6 @@ class PHPCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with AllocateIOLocalVar
     with UniversalFooter
     with UniversalDoc
-    with FixedContentsUsingArrayByteLiteral
     with EveryReadIsExpression {
 
   import PHPCompiler._
@@ -191,9 +190,6 @@ class PHPCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    out.puts(s"${privateMemberName(attrName)} = $normalIO->ensureFixedContents($contents);")
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -479,16 +475,20 @@ class PHPCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = PHPCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "null",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     out.puts(s"if (!(${translator.translate(checkExpr)})) {")
     out.inc
-    out.puts(s"throw new ${ksErrorName(err)}($errArgsStr);")
+    out.puts(s"throw new ${ksErrorName(err)}(${errArgsStr.mkString(", ")});")
     out.dec
     out.puts("}")
   }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/PerlCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/PerlCompiler.scala
index 732da5622..5b0b8badb 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/PerlCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/PerlCompiler.scala
@@ -15,7 +15,6 @@ class PerlCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with UniversalFooter
     with UpperCamelCaseClasses
     with AllocateIOLocalVar
-    with FixedContentsUsingArrayByteLiteral
     with SwitchIfOps
     with EveryReadIsExpression {
 
@@ -163,10 +162,6 @@ class PerlCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit = {
-    out.puts(s"${privateMemberName(attrName)} = $normalIO->ensure_fixed_contents($contents);")
-  }
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/PythonCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/PythonCompiler.scala
index abfda41bb..b58912f17 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/PythonCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/PythonCompiler.scala
@@ -16,8 +16,10 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with SingleOutputFile
     with UniversalFooter
     with EveryReadIsExpression
+    with FetchInstances
+    with EveryWriteIsExpression
+    with GenericChecks
     with AllocateIOLocalVar
-    with FixedContentsUsingArrayByteLiteral
     with UniversalDoc
     with SwitchIfOps
     with NoNeedForFullClassPath {
@@ -28,6 +30,10 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
   override def innerDocstrings = true
 
+  /** See [[subIOWriteBackHeader]] => the code generated when `true` will be inside the definition
+   * of the "write back handler" callback function. */
+  private var inSubIOWriteBackHandler = false
+
   override def universalFooter: Unit = {
     out.dec
     out.puts
@@ -49,7 +55,7 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     outHeader.puts
 
     importList.add("import kaitaistruct")
-    importList.add(s"from kaitaistruct import $kstructName, $kstreamName, BytesIO")
+    importList.add(s"from kaitaistruct import $kstructNameFull, $kstreamName, BytesIO")
 
     out.puts
     out.puts
@@ -89,7 +95,7 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   }
 
   override def classHeader(name: String): Unit = {
-    out.puts(s"class ${type2class(name)}($kstructName):")
+    out.puts(s"class ${type2class(name)}($kstructNameFull):")
     out.inc
   }
 
@@ -97,11 +103,16 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     val endianAdd = if (isHybrid) ", _is_le=None" else ""
     val paramsList = Utils.join(params.map((p) => paramName(p.id)), ", ", ", ", "")
 
-    out.puts(s"def __init__(self$paramsList, _io, _parent=None, _root=None$endianAdd):")
+    val ioDefaultVal = if (config.readWrite) "=None" else ""
+    out.puts(s"def __init__(self$paramsList, _io$ioDefaultVal, _parent=None, _root=None$endianAdd):")
     out.inc
     out.puts("self._io = _io")
     out.puts("self._parent = _parent")
-    out.puts("self._root = _root if _root else self")
+    if (name == rootClassName) {
+      out.puts("self._root = _root if _root else self")
+    } else {
+      out.puts("self._root = _root")
+    }
 
     if (isHybrid)
       out.puts("self._is_le = _is_le")
@@ -120,11 +131,11 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   }
 
   override def runReadCalc(): Unit = {
-    out.puts(s"if not hasattr(self, '_is_le'):")
+    out.puts("if not hasattr(self, '_is_le'):")
     out.inc
     out.puts(s"raise ${ksErrorName(UndecidedEndiannessError)}(" + "\"" + typeProvider.nowClass.path.mkString("/", "/", "") + "\")")
     out.dec
-    out.puts(s"elif self._is_le == True:")
+    out.puts("elif self._is_le == True:")
     out.inc
     out.puts("self._read_le()")
     out.dec
@@ -134,6 +145,21 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.dec
   }
 
+  override def runWriteCalc(): Unit = {
+    out.puts("if not hasattr(self, '_is_le'):")
+    out.inc
+    out.puts(s"raise ${ksErrorName(UndecidedEndiannessError)}(" + "\"" + typeProvider.nowClass.path.mkString("/", "/", "") + "\")")
+    out.dec
+    out.puts("elif self._is_le == True:")
+    out.inc
+    out.puts("self._write__seq_le()")
+    out.dec
+    out.puts("elif self._is_le == False:")
+    out.inc
+    out.puts("self._write__seq_be()")
+    out.dec
+  }
+
   override def readHeader(endian: Option[FixedEndian], isEmpty: Boolean): Unit = {
     val suffix = endian match {
       case Some(e) => s"_${e.toSuffix}"
@@ -145,12 +171,82 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
       out.puts("pass")
   }
 
-  override def readFooter() = universalFooter
+  override def fetchInstancesHeader(): Unit = {
+    out.puts
+    out.puts("def _fetch_instances(self):")
+    out.inc
+    out.puts("pass")
+  }
+
+  override def fetchInstancesFooter: Unit = universalFooter
+
+  override def attrInvokeFetchInstances(baseExpr: Ast.expr, exprType: DataType, dataType: DataType): Unit = {
+    val expr = expression(baseExpr)
+    out.puts(s"$expr._fetch_instances()")
+  }
+
+  override def attrInvokeInstance(instName: InstanceIdentifier): Unit = {
+    out.puts(s"_ = self.${publicMemberName(instName)}")
+  }
+
+  override def writeHeader(endian: Option[FixedEndian], isEmpty: Boolean): Unit = {
+    out.puts
+    endian match {
+      case Some(e) =>
+        out.puts(s"def _write__seq_${e.toSuffix}(self):")
+        out.inc
+        if (isEmpty)
+          out.puts("pass")
+      case None =>
+        out.puts("def _write__seq(self, io=None):")
+        out.inc
+        // FIXME: remove super() args when dropping support for Python 2 (see
+        // https://pylint.readthedocs.io/en/v2.16.2/user_guide/messages/refactor/super-with-arguments.html)
+        out.puts(s"super(${types2class(typeProvider.nowClass.name)}, self)._write__seq(io)")
+    }
+  }
+
+  override def checkHeader(): Unit = {
+    out.puts
+    out.puts("def _check(self):")
+    out.inc
+    out.puts("pass")
+  }
+
+  override def writeInstanceHeader(instName: InstanceIdentifier): Unit = {
+    out.puts
+    out.puts(s"def _write_${publicMemberName(instName)}(self):")
+    out.inc
+    instanceClearWriteFlag(instName)
+  }
+
+  override def checkInstanceHeader(instName: InstanceIdentifier): Unit = {
+    out.puts
+    out.puts(s"def _check_${publicMemberName(instName)}(self):")
+    out.inc
+    out.puts("pass")
+  }
 
   override def attributeDeclaration(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {}
 
   override def attributeReader(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {}
 
+  override def attributeSetter(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = {
+    if (attrName.isInstanceOf[InstanceIdentifier]) {
+      val name = publicMemberName(attrName)
+
+      out.puts(s"@$name.setter")
+      out.puts(s"def $name(self, v):")
+      out.inc
+      handleAssignmentSimple(attrName, "v")
+      out.dec
+    }
+  }
+
+  override def attrSetProperty(base: Ast.expr, propName: Identifier, value: String): Unit = {
+    out.puts(s"${expression(base)}.${publicMemberName(propName)} = $value")
+  }
+
   override def universalDoc(doc: DocSpec): Unit = {
     val docStr = doc.summary match {
       case Some(summary) =>
@@ -179,9 +275,6 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.putsLines("", "\"\"\"" + docStr + refStr + "\"\"\"")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    out.puts(s"${privateMemberName(attrName)} = self._io.ensure_fixed_contents($contents)")
-
   override def attrParseHybrid(leProc: () => Unit, beProc: () => Unit): Unit = {
     out.puts("if self._is_le:")
     out.inc
@@ -224,13 +317,89 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
           importList.add(s"import $pkgName")
           s"$pkgName.${type2class(name.last)}"
         }
-
         out.puts(s"_process = $procClass(${args.map(expression).mkString(", ")})")
         s"_process.decode($srcExpr)"
     }
     handleAssignment(varDest, expr, rep, false)
   }
 
+  override def attrUnprocess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec, dt: BytesType, exprTypeOpt: Option[DataType]): Unit = {
+    val srcExpr = varSrc match {
+      // use `_raw_items[_raw_items.size - 1]`
+      case _: RawIdentifier => getRawIdExpr(varSrc, rep)
+      // but `items[_index]`
+      case _ => expression(itemExpr(varSrc, rep))
+    }
+
+    val expr = proc match {
+      case ProcessXor(xorValue) =>
+        val argStr = if (inSubIOWriteBackHandler) "_process_val" else expression(xorValue)
+        val procName = translator.detectType(xorValue) match {
+          case _: IntType => "process_xor_one"
+          case _: BytesType => "process_xor_many"
+        }
+        s"$kstreamName.$procName($srcExpr, $argStr)"
+      case ProcessZlib =>
+        importList.add("import zlib")
+        s"zlib.compress($srcExpr)"
+      case ProcessRotate(isLeft, rotValue) =>
+        val argStr = if (inSubIOWriteBackHandler) "_process_val" else expression(rotValue)
+        val expr = if (!isLeft) {
+          argStr
+        } else {
+          s"8 - ($argStr)"
+        }
+        s"$kstreamName.process_rotate_left($srcExpr, $expr, 1)"
+      case ProcessCustom(name, args) =>
+        val procClass = if (name.length == 1) {
+          val onlyName = name.head
+          val className = type2class(onlyName)
+          importList.add(s"from $onlyName import $className")
+          className
+        } else {
+          val pkgName = name.init.mkString(".")
+          importList.add(s"import $pkgName")
+          s"$pkgName.${type2class(name.last)}"
+        }
+
+        val procName = if (inSubIOWriteBackHandler) {
+          "_process_val"
+        } else {
+          val procName = s"_process_${idToStr(varSrc)}"
+          out.puts(s"$procName = $procClass(${args.map(expression).mkString(", ")})")
+          procName
+        }
+        s"$procName.encode($srcExpr)"
+    }
+    handleAssignment(varDest, expr, rep, false)
+  }
+
+  override def attrUnprocessPrepareBeforeSubIOHandler(proc: ProcessExpr, varSrc: Identifier): Unit = {
+    // NOTE: the local variable "_process_val" will be captured in a default value of a parameter
+    // when defining the "write back handler" function (in subIOWriteBackHeader), see
+    // https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result
+    proc match {
+      case ProcessXor(xorValue) =>
+        out.puts(s"_process_val = ${expression(xorValue)}")
+      case ProcessRotate(_, rotValue) =>
+        out.puts(s"_process_val = ${expression(rotValue)}")
+      case ProcessZlib => // no process arguments
+      case ProcessCustom(name, args) =>
+        val procClass = if (name.length == 1) {
+          val onlyName = name.head
+          val className = type2class(onlyName)
+          importList.add(s"from $onlyName import $className")
+          className
+        } else {
+          val pkgName = name.init.mkString(".")
+          importList.add(s"import $pkgName")
+          s"$pkgName.${type2class(name.last)}"
+        }
+        val procName = "_process_val"
+        out.puts(s"$procName = $procClass(${args.map(expression).mkString(", ")})")
+    }
+  }
+
   override def normalIO: String = "self._io"
 
   override def allocateIO(varName: Identifier, rep: RepeatSpec): String = {
@@ -243,11 +412,53 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     ioName
   }
 
+  override def allocateIOFixed(varName: Identifier, size: String): String = {
+    val varStr = privateMemberName(varName)
+    val ioName = s"_io_${idToStr(varName)}"
+
+    // NOTE: in Python 2, bytes() converts an integer argument to a string (e.g. bytes(12) => '12'),
+    // so we have to use bytearray() instead
+    out.puts(s"$ioName = $kstreamName(BytesIO(bytearray($size)))")
+    ioName
+  }
+
+  override def exprIORemainingSize(io: String): String =
+    s"$io.size() - $io.pos()"
+
+  override def subIOWriteBackHeader(subIO: String, process: Option[ProcessExpr]): String = {
+    val parentIoName = "parent"
+    // NOTE: local variables "$subIO" and "_process_val" are captured here as default values of
+    // "handler" parameters, see
+    // https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result
+    val processValArg =
+      process.map(proc => proc match {
+        case _: ProcessXor | _: ProcessRotate | _: ProcessCustom =>
+          ", _process_val=_process_val"
+        case _ =>
+          ""
+      }).getOrElse("")
+    out.puts(s"def handler(parent, $subIO=$subIO$processValArg):")
+    out.inc
+
+    inSubIOWriteBackHandler = true
+
+    parentIoName
+  }
+
+  override def subIOWriteBackFooter(subIO: String): Unit = {
+    inSubIOWriteBackHandler = false
+
+    out.dec
+    out.puts(s"$subIO.write_back_handler = $kstreamName.WriteBackHandler(_pos2, handler)")
+  }
+
+  override def addChildIO(io: String, childIO: String): Unit =
+    out.puts(s"$io.add_child_stream($childIO)")
+
   def getRawIdExpr(varName: Identifier, rep: RepeatSpec): String = {
     val memberName = privateMemberName(varName)
     rep match {
       case NoRepeat => memberName
-      case RepeatExpr(_) => s"$memberName[i]"
       case _ => s"$memberName[-1]"
     }
   }
@@ -260,14 +471,22 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def pushPos(io: String): Unit =
     out.puts(s"_pos = $io.pos()")
 
+  override def pushPosForSubIOWriteBackHandler(io: String): Unit =
+    out.puts(s"_pos2 = $io.pos()")
+
   override def seek(io: String, pos: Ast.expr): Unit =
     out.puts(s"$io.seek(${expression(pos)})")
 
+  override def seekRelative(io: String, relPos: String): Unit =
+    out.puts(s"$io.seek($io.pos() + ($relPos))")
+
   override def popPos(io: String): Unit =
     out.puts(s"$io.seek(_pos)")
 
-  override def alignToByte(io: String): Unit =
-    out.puts(s"$io.align_to_byte()")
+  // NOTE: the compiler does not need to output align_to_byte() calls for Python anymore,
+  // since the byte alignment is handled by the runtime library since commit
+  // https://github.com/kaitai-io/kaitai_struct_python_runtime/commit/1cb84b84d358e1cdffe35845d1e6688bff923952
+  override def alignToByte(io: String): Unit = {}
 
   override def attrDebugStart(attrId: Identifier, attrType: DataType, ios: Option[String], rep: RepeatSpec): Unit = {
     ios.foreach { (io) =>
@@ -299,6 +518,7 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def condIfHeader(expr: Ast.expr): Unit = {
     out.puts(s"if ${expression(expr)}:")
     out.inc
+    out.puts("pass")
   }
 
   override def condRepeatInitAttr(id: Identifier, dataType: DataType): Unit =
@@ -321,6 +541,16 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts(s"for i in range(${expression(repeatExpr)}):")
     out.inc
   }
+
+  // used for all repetitions in _check()
+  override def condRepeatCommonHeader(id: Identifier, io: String, dataType: DataType): Unit = {
+    // TODO: replace range(len()) with enumerate() (see
+    // https://pylint.readthedocs.io/en/v2.16.2/user_guide/messages/convention/consider-using-enumerate.html)
+    out.puts(s"for i in range(len(${privateMemberName(id)})):")
+    out.inc
+    out.puts("pass")
+  }
+
   override def handleAssignmentRepeatExpr(id: Identifier, expr: String): Unit =
     handleAssignmentRepeatEos(id, expr)
 
@@ -388,8 +618,9 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
 
   override def bytesPadTermExpr(expr0: String, padRight: Option[Int], terminator: Option[Int], include: Boolean) = {
     val expr1 = padRight match {
-      case Some(padByte) => s"$kstreamName.bytes_strip_right($expr0, $padByte)"
-      case None => expr0
+      case Some(padByte) if terminator.map(term => padByte != term).getOrElse(true) =>
+        s"$kstreamName.bytes_strip_right($expr0, $padByte)"
+      case _ => expr0
     }
     val expr2 = terminator match {
       case Some(term) => s"$kstreamName.bytes_terminate($expr1, $term, ${bool2Py(include)})"
@@ -415,11 +646,13 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def switchIfCaseFirstStart(condition: Ast.expr): Unit = {
     out.puts(s"if _on == ${expression(condition)}:")
     out.inc
+    out.puts("pass")
   }
 
   override def switchIfCaseStart(condition: Ast.expr): Unit = {
     out.puts(s"elif _on == ${expression(condition)}:")
     out.inc
+    out.puts("pass")
   }
 
   override def switchIfCaseEnd(): Unit =
@@ -428,10 +661,28 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def switchIfElseStart(): Unit = {
     out.puts(s"else:")
     out.inc
+    out.puts("pass")
   }
 
   override def switchIfEnd(): Unit = {}
 
+  override def instanceWriteFlagDeclaration(attrName: InstanceIdentifier): Unit = {}
+
+  override def instanceWriteFlagInit(attrName: InstanceIdentifier): Unit = {
+    instanceClearWriteFlag(attrName)
+    out.puts(s"self.${publicMemberName(attrName)}__to_write = True")
+  }
+
+  override def instanceSetWriteFlag(instName: InstanceIdentifier): Unit = {
+    out.puts(s"self._should_write_${publicMemberName(instName)} = self.${publicMemberName(instName)}__to_write")
+  }
+
+  override def instanceClearWriteFlag(instName: InstanceIdentifier): Unit = {
+    out.puts(s"self._should_write_${publicMemberName(instName)} = False")
+  }
+
+  override def instanceToWriteSetter(instName: InstanceIdentifier): Unit = {}
+
   override def instanceHeader(className: String, instName: InstanceIdentifier, dataType: DataType, isNullable: Boolean): Unit = {
     out.puts("@property")
     out.puts(s"def ${publicMemberName(instName)}(self):")
@@ -446,11 +697,25 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts
   }
 
+  override def instanceCheckWriteFlagAndWrite(instName: InstanceIdentifier): Unit = {
+    out.puts(s"if self._should_write_${publicMemberName(instName)}:")
+    out.inc
+    out.puts(s"self._write_${publicMemberName(instName)}()")
+    out.dec
+  }
+
   override def instanceReturn(instName: InstanceIdentifier, attrType: DataType): Unit = {
     // workaround to avoid Python raising an "AttributeError: instance has no attribute"
     out.puts(s"return getattr(self, '${idToStr(instName)}', None)")
   }
 
+  override def instanceInvalidate(instName: InstanceIdentifier): Unit = {
+    out.puts(s"def _invalidate_${publicMemberName(instName)}(self):")
+    out.inc
+    out.puts(s"del ${privateMemberName(instName)}")
+    out.dec
+  }
+
   override def enumDeclaration(curClass: String, enumName: String, enumColl: Seq[(Long, String)]): Unit = {
     importList.add("from enum import IntEnum")
 
@@ -461,6 +726,9 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.dec
   }
 
+  override def internalEnumIntType(basedOn: IntType): DataType =
+    basedOn
+
   override def debugClassSequence(seq: List[AttrSpec]) = {
     val seqStr = seq.map((attr) => "\"" + idToStr(attr.id) + "\"").mkString(", ")
     out.puts(s"SEQ_FIELDS = [$seqStr]")
@@ -474,6 +742,107 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.dec
   }
 
+  override def attrPrimitiveWrite(
+    io: String,
+    valueExpr: Ast.expr,
+    dataType: DataType,
+    defEndian: Option[FixedEndian],
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    val expr = expression(valueExpr)
+
+    val stmt = dataType match {
+      case t: ReadableType =>
+        s"$io.write_${t.apiCall(defEndian)}($expr)"
+      case BitsType1(bitEndian) =>
+        s"$io.write_bits_int_${bitEndian.toSuffix}(1, ${translator.boolToInt(valueExpr)})"
+      case BitsType(width: Int, bitEndian) =>
+        s"$io.write_bits_int_${bitEndian.toSuffix}($width, $expr)"
+      case _: BytesType =>
+        s"$io.write_bytes($expr)"
+    }
+    out.puts(stmt)
+  }
+
+  override def attrBytesLimitWrite(io: String, expr: Ast.expr, size: String, term: Int, padRight: Int): Unit =
+    out.puts(s"$io.write_bytes_limit(${expression(expr)}, $size, $term, $padRight)")
+
+  override def attrUserTypeInstreamWrite(io: String, valueExpr: Ast.expr, dataType: DataType, exprType: DataType) = {
+    val expr = expression(valueExpr)
+    out.puts(s"$expr._write__seq($io)")
+  }
+
+  override def exprStreamToByteArray(io: String): String =
+    s"$io.to_byte_array()"
+
+  override def attrBasicCheck(checkExpr: Ast.expr, actual: Ast.expr, expected: Ast.expr, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if ${expression(checkExpr)}:")
+    out.inc
+    out.puts(s"raise kaitaistruct.ConsistencyError($msgStr, ${expression(actual)}, ${expression(expected)})")
+    out.dec
+  }
+
+  override def attrObjectsEqualCheck(actual: Ast.expr, expected: Ast.expr, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if ${expression(actual)} != ${expression(expected)}:")
+    out.inc
+    out.puts(s"raise kaitaistruct.ConsistencyError($msgStr, ${expression(actual)}, ${expression(expected)})")
+    out.dec
+  }
+
+  override def attrParentParamCheck(actualParentExpr: Ast.expr, ut: UserType, shouldDependOnIo: Option[Boolean], msg: String): Unit = {
+    if (ut.isOpaque)
+      return
+    /** @note Must be kept in sync with [[PythonCompiler.parseExpr]] */
+    val (expectedParent, dependsOnIo) = ut.forcedParent match {
+      case Some(USER_TYPE_NO_PARENT) => ("None", false)
+      case Some(fp) =>
+        (expression(fp), userExprDependsOnIo(fp))
+      case None => ("self", false)
+    }
+    if (shouldDependOnIo.map(shouldDepend => dependsOnIo != shouldDepend).getOrElse(false))
+      return
+
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    out.puts(s"if ${expression(actualParentExpr)} != $expectedParent:")
+    out.inc
+    out.puts(s"raise kaitaistruct.ConsistencyError($msgStr, ${expression(actualParentExpr)}, $expectedParent)")
+    out.dec
+  }
+
+  override def attrIsEofCheck(io: String, expectedIsEof: Boolean, msg: String): Unit = {
+    val msgStr = expression(Ast.expr.Str(msg))
+
+    val eofExpr = s"$io.is_eof()"
+    val ifExpr = if (expectedIsEof) {
+      s"not $eofExpr"
+    } else {
+      eofExpr
+    }
+    out.puts(s"if $ifExpr:")
+    out.inc
+    out.puts(s"raise kaitaistruct.ConsistencyError($msgStr, ${exprIORemainingSize(io)}, 0)")
+    out.dec
+  }
+
+  override def condIfIsEofHeader(io: String, wantedIsEof: Boolean): Unit = {
+    val eofExpr = s"$io.is_eof()"
+    val ifExpr = if (!wantedIsEof) {
+      s"not $eofExpr"
+    } else {
+      eofExpr
+    }
+
+    out.puts(s"if $ifExpr:")
+    out.inc
+  }
+
+  override def condIfIsEofFooter: Unit = universalFooter
+
   def bool2Py(b: Boolean): String = if (b) { "True" } else { "False" }
 
   override def idToStr(id: Identifier): String = PythonCompiler.idToStr(id)
@@ -487,19 +856,30 @@ class PythonCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = PythonCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "None",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
     out.puts(s"if not ${translator.translate(checkExpr)}:")
     out.inc
-    out.puts(s"raise ${ksErrorName(err)}($errArgsStr)")
+    out.puts(s"raise ${ksErrorName(err)}(${errArgsStr.mkString(", ")})")
     out.dec
   }
 
+  def kstructNameFull: String = {
+    ((config.autoRead, config.readWrite) match {
+      case (_, true) => "ReadWrite"
+      case (_, false) => ""
+    }) + kstructName
+  }
+
   def userType2class(t: UserType): String = {
     val name = t.classSpec.get.name
     val firstName = name.head
@@ -528,6 +908,8 @@ object PythonCompiler extends LanguageCompilerStatic
       case NumberedIdentifier(idx) => s"_${NumberedIdentifier.TEMPLATE}$idx"
       case InstanceIdentifier(name) => s"_m_$name"
       case RawIdentifier(innerId) => s"_raw_${idToStr(innerId)}"
+      case OuterSizeIdentifier(innerId) => s"${idToStr(innerId)}__outer_size"
+      case InnerSizeIdentifier(innerId) => s"${idToStr(innerId)}__inner_size"
     }
 
   def publicMemberName(id: Identifier): String =
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/RubyCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/RubyCompiler.scala
index 6ce5d98e9..b38f572c4 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/RubyCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/RubyCompiler.scala
@@ -18,7 +18,6 @@ class RubyCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with UpperCamelCaseClasses
     with AllocateIOLocalVar
     with EveryReadIsExpression
-    with FixedContentsUsingArrayByteLiteral
     with NoNeedForFullClassPath {
 
   import RubyCompiler._
@@ -174,9 +173,6 @@ class RubyCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("end")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    out.puts(s"${privateMemberName(attrName)} = $normalIO.ensure_fixed_contents($contents)")
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
@@ -460,14 +456,18 @@ class RubyCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
   override def ksErrorName(err: KSError): String = RubyCompiler.ksErrorName(err)
 
   override def attrValidateExpr(
-    attrId: Identifier,
-    attrType: DataType,
+    attr: AttrLikeSpec,
     checkExpr: Ast.expr,
     err: KSError,
-    errArgs: List[Ast.expr]
+    useIo: Boolean,
+    expected: Option[Ast.expr] = None
   ): Unit = {
-    val errArgsStr = errArgs.map(translator.translate).mkString(", ")
-    out.puts(s"raise ${ksErrorName(err)}.new($errArgsStr) if not ${translator.translate(checkExpr)}")
+    val errArgsStr = expected.map(expression) ++ List(
+      expression(Ast.expr.InternalName(attr.id)),
+      if (useIo) expression(Ast.expr.InternalName(IoIdentifier)) else "nil",
+      expression(Ast.expr.Str(attr.path.mkString("/", "/", "")))
+    )
+    out.puts(s"raise ${ksErrorName(err)}.new(${errArgsStr.mkString(", ")}) if not ${translator.translate(checkExpr)}")
   }
 
   def types2class(names: List[String]) = names.map(type2class).mkString("::")
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/RustCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/RustCompiler.scala
index 0e55cb402..8afcc65cb 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/RustCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/RustCompiler.scala
@@ -16,7 +16,6 @@ class RustCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     with AllocateIOLocalVar
     with UniversalFooter
     with UniversalDoc
-    with FixedContentsUsingArrayByteLiteral
     with EveryReadIsExpression {
 
   import RustCompiler._
@@ -170,9 +169,6 @@ class RustCompiler(typeProvider: ClassTypeProvider, config: RuntimeConfig)
     out.puts("}")
   }
 
-  override def attrFixedContentsParse(attrName: Identifier, contents: String): Unit =
-    out.puts(s"${privateMemberName(attrName)} = $normalIO.ensureFixedContents($contents);")
-
   override def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit = {
     val srcExpr = getRawIdExpr(varSrc, rep)
 
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/AllocateIOLocalVar.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/AllocateIOLocalVar.scala
index fd84dce12..32cb79047 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/AllocateIOLocalVar.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/AllocateIOLocalVar.scala
@@ -9,5 +9,21 @@ import io.kaitai.struct.format.{AttrSpec, Identifier, RepeatSpec}
 trait AllocateIOLocalVar extends ExtraAttrs {
   def allocateIO(varName: Identifier, rep: RepeatSpec): String
 
+  /**
+    * Allocates a fixed-size KaitaiStream IO object for writing into it.
+    * @param varName variable name to use to generate IO name
+    * @param size size expression to use
+    * @return name of generated IO local variable as string
+    */
+  def allocateIOFixed(varName: Identifier, size: String): String = ???
+
+  /**
+    * Allocates a growing KaitaiStream IO object for writing into it.
+    * This one is expected to grow indefinitely as one writes more data
+    * into it, never raising a buffer overflow exception
+    * @param varName variable name to use to generate IO name
+    * @return name of generated IO local variable as string
+    */
+  def allocateIOGrowing(varName: Identifier): String = ???
   override def extraAttrForIO(id: Identifier, rep: RepeatSpec): List[AttrSpec] = List()
 }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/CommonChecks.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/CommonChecks.scala
new file mode 100644
index 000000000..bca0e5123
--- /dev/null
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/CommonChecks.scala
@@ -0,0 +1,506 @@
+package io.kaitai.struct.languages.components
+import io.kaitai.struct.datatype.DataType
+import io.kaitai.struct.datatype.DataType._
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format._
+
+trait CommonChecks extends LanguageCompiler with CommonReads {
+  override def attrCheck(attr: AttrLikeSpec, id: Identifier): Unit = {
+    val bodyShouldDependOnIo: Option[Boolean] =
+      if (userExprDependsOnIo(attr.cond.ifExpr)) {
+        return
+      } else {
+        Some(false)
+      }
+
+    attrParseIfHeader(id, attr.cond.ifExpr)
+
+    val io = normalIO
+
+    attr.cond.repeat match {
+      case RepeatEos =>
+        condRepeatCommonHeader(id, io, attr.dataType)
+        attrCheck2(id, attr.dataType, attr.cond.repeat, bodyShouldDependOnIo)
+        condRepeatCommonFooter
+      case RepeatExpr(repeatExpr: Ast.expr) =>
+        attrRepeatExprCheck(id, repeatExpr, bodyShouldDependOnIo)
+        condRepeatCommonHeader(id, io, attr.dataType)
+        attrCheck2(id, attr.dataType, attr.cond.repeat, bodyShouldDependOnIo)
+        condRepeatCommonFooter
+      case repUntil: RepeatUntil =>
+        attrAssertUntilNotEmpty(id)
+        condRepeatCommonHeader(id, io, attr.dataType)
+        attrCheck2(id, attr.dataType, attr.cond.repeat, bodyShouldDependOnIo)
+        attrAssertUntilCond(id, attr.dataType, repUntil, bodyShouldDependOnIo)
+        condRepeatCommonFooter
+      case NoRepeat =>
+        attrCheck2(id, attr.dataType, attr.cond.repeat, bodyShouldDependOnIo)
+    }
+    // TODO: move to attrCheck2 when we change the `valid` semantics to apply to each item
+    // in repeated fields, not the entire array (see
+    // https://github.com/kaitai-io/kaitai_struct_formats/issues/347)
+    attr.valid.foreach { (valid) =>
+      typeProvider._currentIteratorType = Some(attr.dataTypeComposite)
+      if (bodyShouldDependOnIo.map(shouldDepend => validDependsOnIo(valid) == shouldDepend).getOrElse(true)) {
+        attrValidate(id, attr, valid, false)
+      }
+    }
+
+    attrParseIfFooter(attr.cond.ifExpr)
+  }
+
+
+
+  def userExprDependsOnIo(expr: Option[Ast.expr]): Boolean = expr match {
+    case None => false
+    case Some(v) => userExprDependsOnIo(v)
+  }
+
+  def getArrayItemType(dt: DataType): DataType = {
+    dt match {
+      case arr: ArrayType => getArrayItemType(arr.elType)
+      case other => other
+    }
+  }
+
+  def userExprDependsOnIo(expr: Ast.expr): Boolean = {
+    expr match {
+      case _: Ast.expr.IntNum => false
+      case _: Ast.expr.FloatNum => false
+      case _: Ast.expr.Str => false
+      case _: Ast.expr.Bool => false
+      case _: Ast.expr.EnumById => false
+      case _: Ast.expr.EnumByLabel => false
+      case n: Ast.expr.Name =>
+        val t = getArrayItemType(translator.detectType(n))
+        if (t == KaitaiStreamType || t == OwnedKaitaiStreamType) {
+          true
+        } else {
+          /** @see [[ClassTypeProvider.determineType(inClass:ClassSpec,attrName:String):DataType*]] */
+          n.id.name match {
+            case Identifier.ROOT
+                 | Identifier.PARENT
+                 | Identifier.IO
+                 | Identifier.ITERATOR
+                 | Identifier.SWITCH_ON
+                 | Identifier.INDEX
+                 | Identifier.SIZEOF
+            => false
+            case _ =>
+              val spec = typeProvider.resolveMember(typeProvider.nowClass, n.id.name)
+              spec match {
+                case _: AttrSpec => false
+
+                // Parameters are fine because they are normally set by the user, so are already
+                // available in _check(). The only parameters set by the generated code in _write()
+                // (not by the user) are params of type KaitaiStream or an array of KaitaiStream,
+                // but these were caught earlier in this function.
+                case _: ParamDefSpec => false
+
+                // Value instances are OK to use in _check() if their expressions in `value` and
+                // `if` do not use _io or parse instances. They can refer to other value instances,
+                // provided they follow the same conditions (which is ensured by a recursive call).
+                case vis: ValueInstanceSpec =>
+                  userExprDependsOnIo(vis.ifExpr) || userExprDependsOnIo(vis.value)
+
+                // Although accessing parse instances in _check() is not a problem by itself,
+                // because parse instances are set by the user so they are already available in
+                // _check(), it becomes a problem when you don't invoke a parse instance dependent
+                // on the time of invocation in _write() because you have already done a particular
+                // check in _check().
+                //
+                // Take the test
+                // https://github.com/kaitai-io/kaitai_struct_tests/blob/010efd1d9c07a61a320a644d4e782dd488ba28e4/formats/instance_in_repeat_until.ksy
+                // as an example. In _write() you don't need to reproduce the special `do { ... }
+                // while (!repeat-until);` loop as used in _read(), because you already know the
+                // array length, so a simple "foreach" loop will suffice. Then there is a
+                // consistency check to ensure that the `repeat-until` condition is `false` for all
+                // items except the last one, and `true` for the last one. This check can be either
+                // done in _check(), or in _write() at the end of each iteration of the "foreach"
+                // loop. You can do it in _check() if you want, but you *need* to evaluate the
+                // `repeat-until` expression (and throw away the result, if you like - the point is
+                // just to invoke the parse instances specified there) at the end of each "foreach"
+                // loop iteration in _write(), because _read() does that. So it makes sense to do
+                // the check only in _write().
+                //
+                // It may be tempting to suggest to do the check both in _check() and _write(), and
+                // in this particular case you could really do that because the parse instance is
+                // used directly in the `repeat-until` expression. But if such parse instance is used
+                // indirectly via a value instance, you should no longer use that value instance in
+                // _check() at all, because that would cache the its value and the invocation in
+                // _write() would merely return this cached value, not evaluating the expression
+                // again. But that means that the parse instance will be written at a different
+                // time, because it won't be invoked from `seq` at the time it would be in _read()
+                // and will be written only when invoked from _fetchInstances(), which is wrong and
+                // inconsistent with parsing. Although the user could work around this specific
+                // issue by manually invalidating the value instances that the careless _check()
+                // invoked after calling it, this would be a bug in _check(). Calling _check()
+                // should not have side effects that the user has to "undo".
+                //
+                // Of course, perhaps most parse instances are not dependent on the time of
+                // invocation. But the language allows them to be, and it's not that trivial to
+                // detect it: you have to analyze all expressions that affect its parsing. So we
+                // will not do that for now - it's easier to avoid invoking parse instances in
+                // _check() (directly or indirectly) entirely.
+                case _: ParseInstanceSpec => true
+              }
+          }
+        }
+      case Ast.expr.InternalName(id) =>
+        ???
+      case Ast.expr.UnaryOp(op, inner) =>
+        userExprDependsOnIo(inner)
+      case Ast.expr.Compare(left, op, right) =>
+        userExprDependsOnIo(left) || userExprDependsOnIo(right)
+      case Ast.expr.BinOp(left, op, right) =>
+        userExprDependsOnIo(left) || userExprDependsOnIo(right)
+      case Ast.expr.BoolOp(op, values) =>
+        values.exists(v => userExprDependsOnIo(v))
+      case Ast.expr.IfExp(condition, ifTrue, ifFalse) =>
+        userExprDependsOnIo(condition) || userExprDependsOnIo(ifTrue) || userExprDependsOnIo(ifFalse)
+      case Ast.expr.Subscript(value, idx) =>
+        userExprDependsOnIo(value) || userExprDependsOnIo(idx)
+      case a: Ast.expr.Attribute =>
+        val t = getArrayItemType(translator.detectType(a))
+        if (t == KaitaiStreamType || t == OwnedKaitaiStreamType) {
+          true
+        } else {
+          userExprDependsOnIo(a.value)
+        }
+      case Ast.expr.Call(func, args) =>
+        (func match {
+          case Ast.expr.Attribute(value, methodName) =>
+            userExprDependsOnIo(value)
+        }) || args.exists(v => userExprDependsOnIo(v))
+      case Ast.expr.List(values: Seq[Ast.expr]) =>
+        values.exists(v => userExprDependsOnIo(v))
+      case Ast.expr.CastToType(value, typeName) =>
+        userExprDependsOnIo(value)
+      case _: Ast.expr.ByteSizeOfType => false
+      case _: Ast.expr.BitSizeOfType => false
+    }
+  }
+
+  def validDependsOnIo(valid: ValidationSpec): Boolean = {
+    valid match {
+      case ValidationEq(expected) => userExprDependsOnIo(expected)
+      case ValidationMin(min) => userExprDependsOnIo(min)
+      case ValidationMax(max) => userExprDependsOnIo(max)
+      case ValidationRange(min, max) => userExprDependsOnIo(min) || userExprDependsOnIo(max)
+      case ValidationAnyOf(values) => values.exists(v => userExprDependsOnIo(v))
+      case ValidationExpr(expr) => userExprDependsOnIo(expr)
+    }
+  }
+
+  def attrCheck2(id: Identifier, dataType: DataType, repeat: RepeatSpec, shouldDependOnIo: Option[Boolean], exprTypeOpt: Option[DataType] = None): Unit
+
+  def attrRepeatExprCheck(id: Identifier, expectedSize: Ast.expr, shouldDependOnIo: Option[Boolean]): Unit = {
+    if (shouldDependOnIo.map(shouldDepend => userExprDependsOnIo(expectedSize) != shouldDepend).getOrElse(false))
+      return
+    attrAssertEqual(
+      exprArraySize(Ast.expr.InternalName(id)),
+      expectedSize,
+      idToMsg(id)
+    )
+  }
+
+  def attrBytesCheck(id: Identifier, bytes: Ast.expr, t: BytesType, shouldDependOnIoOrig: Option[Boolean]): Unit = {
+    val shouldDependOnIo: Option[Boolean] =
+      if (t.process.isDefined) {
+        if (shouldDependOnIoOrig.getOrElse(true)) {
+          None
+        } else {
+          return
+        }
+      } else {
+        shouldDependOnIoOrig
+      }
+
+    val msgId = idToMsg(id)
+    val actualSize = exprByteArraySize(bytes)
+    val canUseNonIoDependent = shouldDependOnIo.map(shouldDepend => shouldDepend == false).getOrElse(true)
+    t match {
+      case blt: BytesLimitType => {
+        val limitSize = blt.size
+        val canUseLimitSize = shouldDependOnIo.map(shouldDepend => userExprDependsOnIo(limitSize) == shouldDepend).getOrElse(true)
+        if (canUseLimitSize) {
+          if (blt.terminator.isDefined || blt.padRight.isDefined) {
+            // size must be "<= declared" (less than or equal to declared size)
+            attrAssertLtE(actualSize, limitSize, msgId)
+          } else {
+            // size must match declared size exactly
+            attrAssertEqual(
+              actualSize,
+              limitSize,
+              msgId
+            )
+          }
+        }
+        blt.terminator match {
+          case Some(term) => {
+            val actualIndexOfTerm = exprByteArrayIndexOf(bytes, term)
+            val isPadRightActive = blt.padRight.map(padByte => padByte != term).getOrElse(false)
+            if (!blt.include) {
+              if (canUseNonIoDependent) {
+                attrAssertEqual(actualIndexOfTerm, Ast.expr.IntNum(-1), msgId)
+              }
+              if (isPadRightActive && canUseLimitSize) {
+                condIfHeader(Ast.expr.Compare(actualSize, Ast.cmpop.Eq, limitSize))
+                // check if the last byte is not `pad-right`
+                attrBytesPadRightCheck(bytes, actualSize, blt.padRight, msgId)
+                condIfFooter
+              }
+            } else {
+              val lastByteIndex = Ast.expr.BinOp(actualSize, Ast.operator.Sub, Ast.expr.IntNum(1))
+              if (!isPadRightActive && canUseLimitSize) {
+                condIfHeader(Ast.expr.Compare(actualSize, Ast.cmpop.Lt, limitSize))
+                // must not be empty (always contains at least the `terminator` byte)
+                attrAssertCmp(actualSize, Ast.cmpop.Eq, Ast.expr.IntNum(0), msgId)
+                // the user wants to terminate the value prematurely and there's no `pad-right` that
+                // could do that, so the last byte of the value must be `terminator`
+                attrAssertEqual(actualIndexOfTerm, lastByteIndex, msgId)
+                condIfFooter
+
+                condIfHeader(Ast.expr.Compare(actualSize, Ast.cmpop.Eq, limitSize))
+                attrTermIncludeCheck(actualIndexOfTerm, lastByteIndex, msgId)
+                condIfFooter
+              }
+              if (isPadRightActive && canUseNonIoDependent) {
+                attrTermIncludeCheck(actualIndexOfTerm, lastByteIndex, msgId)
+
+                condIfHeader(Ast.expr.Compare(actualIndexOfTerm, Ast.cmpop.Eq, Ast.expr.IntNum(-1)))
+                // check if the last byte is not `pad-right`
+                attrBytesPadRightCheck(bytes, actualSize, blt.padRight, msgId)
+                condIfFooter
+              }
+            }
+          }
+          case None =>
+            if (canUseLimitSize) {
+              // check if the last byte is not `pad-right`
+              attrBytesPadRightCheck(bytes, actualSize, blt.padRight, msgId)
+            }
+        }
+      }
+      case btt: BytesTerminatedType => {
+        if (canUseNonIoDependent) {
+          val actualIndexOfTerm = exprByteArrayIndexOf(bytes, btt.terminator)
+          val lastByteIndex: Ast.expr = Ast.expr.BinOp(actualSize, Ast.operator.Sub, Ast.expr.IntNum(1))
+          val expectedIndexOfTerm = if (btt.include) {
+            if (btt.eosError) {
+              // must not be empty (always contains at least the `terminator` byte)
+              attrAssertCmp(actualSize, Ast.cmpop.Eq, Ast.expr.IntNum(0), msgId)
+
+              attrAssertEqual(actualIndexOfTerm, lastByteIndex, msgId)
+            } else {
+              attrTermIncludeCheck(actualIndexOfTerm, lastByteIndex, msgId)
+            }
+          } else {
+            attrAssertEqual(actualIndexOfTerm, Ast.expr.IntNum(-1), msgId)
+          }
+        }
+      }
+      case _ => // no checks
+    }
+  }
+
+  def attrBytesPadRightCheck(bytes: Ast.expr, actualSize: Ast.expr, padRight: Option[Int], msgId: String): Unit =
+    padRight.foreach { (padByte) =>
+      val lastByte = exprByteArrayLast(bytes)
+      attrBasicCheck(
+        Ast.expr.BoolOp(
+          Ast.boolop.And,
+          Seq(
+            Ast.expr.Compare(actualSize, Ast.cmpop.NotEq, Ast.expr.IntNum(0)),
+            Ast.expr.Compare(
+              lastByte,
+              Ast.cmpop.Eq,
+              Ast.expr.IntNum(padByte)
+            )
+          )
+        ),
+        lastByte,
+        Ast.expr.IntNum(padByte),
+        msgId
+      )
+    }
+
+  def attrTermIncludeCheck(actualIndexOfTerm: Ast.expr, lastByteIndex: Ast.expr, msgId: String): Unit =
+    attrBasicCheck(
+      Ast.expr.BoolOp(
+        Ast.boolop.And,
+        Seq(
+          Ast.expr.Compare(actualIndexOfTerm, Ast.cmpop.NotEq, Ast.expr.IntNum(-1)),
+          Ast.expr.Compare(actualIndexOfTerm, Ast.cmpop.NotEq, lastByteIndex)
+        )
+      ),
+      actualIndexOfTerm,
+      lastByteIndex,
+      msgId
+    )
+
+  def attrUserTypeCheck(id: Identifier, utExpr: Ast.expr, ut: UserType, shouldDependOnIo: Option[Boolean]): Unit = {
+    /** @note Must be kept in sync with [[JavaCompiler.parseExpr]] */
+    if (!ut.isOpaque) {
+      attrUserTypeParamCheck(id, ut, utExpr, RootIdentifier, CalcKaitaiStructType(), Ast.expr.Name(Ast.identifier(Identifier.ROOT)), shouldDependOnIo)
+    }
+    attrParentParamCheck(id, Ast.expr.Attribute(utExpr, Ast.identifier(Identifier.PARENT)), ut, shouldDependOnIo)
+    (ut.classSpec.get.params, ut.args).zipped.foreach { (paramDef, argExpr) =>
+      attrUserTypeParamCheck(id, ut, utExpr, paramDef.id, paramDef.dataType, argExpr, shouldDependOnIo)
+    }
+  }
+
+  def attrUserTypeParamCheck(id: Identifier, ut: UserType, utExpr: Ast.expr, paramId: Identifier, paramDataType: DataType, argExpr: Ast.expr, shouldDependOnIo: Option[Boolean]): Unit = {
+    val paramItemType = getArrayItemType(paramDataType)
+    val paramBasedOnIo = (paramItemType == KaitaiStreamType || paramItemType == OwnedKaitaiStreamType)
+    // parameters with types `io` or `io[]` never have to be checked for consistency because they're set by the generated code
+    if (paramBasedOnIo)
+      return
+    if (shouldDependOnIo.map(shouldDepend => userExprDependsOnIo(argExpr) != shouldDepend).getOrElse(false))
+      return
+    val paramAttrName = paramId match {
+      case NamedIdentifier(name) => name
+      case SpecialIdentifier(name) => name
+    }
+    val actualArgExpr = Ast.expr.Attribute(utExpr, Ast.identifier(paramAttrName))
+    val msgId = idToMsg(id)
+    paramDataType match {
+      /** @note Must be kept in sync with [[translators.BaseTranslator.translate]] */
+      case _: NumericType | _: BooleanType | _: StrType | _: BytesType | _: EnumType =>
+        attrAssertEqual(actualArgExpr, argExpr, msgId)
+      case _: ArrayType =>
+        attrObjectsEqualCheck(actualArgExpr, argExpr, msgId)
+      case _: StructType =>
+        attrObjectsEqualCheck(actualArgExpr, argExpr, msgId)
+      case AnyType =>
+        attrObjectsEqualCheck(actualArgExpr, argExpr, msgId)
+    }
+  }
+
+  def attrSwitchCheck(
+                       id: Identifier,
+                       on: Ast.expr,
+                       cases: Map[Ast.expr, DataType],
+                       rep: RepeatSpec,
+                       shouldDependOnIoOrig: Option[Boolean],
+                       assignType: DataType
+                     ): Unit = {
+    val shouldDependOnIo: Option[Boolean] =
+      if (userExprDependsOnIo(on)) {
+        if (shouldDependOnIoOrig.getOrElse(true)) {
+          None
+        } else {
+          return
+        }
+      } else {
+        shouldDependOnIoOrig
+      }
+
+    switchCases[DataType](id, on, cases,
+      (dataType) => {
+        attrCheck2(id, dataType, rep, shouldDependOnIo, Some(assignType))
+      },
+      (dataType) => if (switchBytesOnlyAsRaw) {
+        dataType match {
+          case t: BytesType =>
+            attrCheck2(RawIdentifier(id), dataType, rep, shouldDependOnIo, Some(assignType))
+          case _ =>
+            attrCheck2(id, dataType, rep, shouldDependOnIo, Some(assignType))
+        }
+      } else {
+        attrCheck2(id, dataType, rep, shouldDependOnIo, Some(assignType))
+      }
+    )
+  }
+
+  def attrBasicCheck(checkExpr: Ast.expr, actual: Ast.expr, expected: Ast.expr, msg: String): Unit
+
+  // This may turn out to be too Java-specific method, so we can refactor it later.
+  def attrObjectsEqualCheck(actual: Ast.expr, expected: Ast.expr, msg: String): Unit
+
+  private
+  def idToMsg(id: Identifier): String = id.humanReadable
+
+  def exprByteArraySize(name: Ast.expr) =
+    Ast.expr.Attribute(
+      name,
+      Ast.identifier("size")
+    )
+
+  def exprByteArrayLast(name: Ast.expr) =
+    Ast.expr.Attribute(
+      name,
+      Ast.identifier("last")
+    )
+
+  def exprByteArrayIndexOf(name: Ast.expr, term: Int) =
+    Ast.expr.Call(
+      Ast.expr.Attribute(
+        name,
+        Ast.identifier("index_of")
+      ),
+      Seq(Ast.expr.IntNum(term))
+    )
+
+  def exprStrToBytes(name: Ast.expr, encoding: String) =
+    Ast.expr.Call(
+      Ast.expr.Attribute(
+        name,
+        Ast.identifier("to_b")
+      ),
+      Seq(Ast.expr.Str(encoding))
+    )
+
+  def exprArraySize(name: Ast.expr) = exprByteArraySize(name)
+
+  def exprArrayLast(name: Ast.expr) = exprByteArrayLast(name)
+
+  def attrAssertUntilNotEmpty(id: Identifier): Unit = {
+    // the array must not be empty (always contains at least the `repeat-until: {true}` element)
+    attrAssertCmp(exprArraySize(Ast.expr.InternalName(id)), Ast.cmpop.Eq, Ast.expr.IntNum(0), idToMsg(id))
+  }
+
+  def attrAssertUntilCond(id: Identifier, dataType: DataType, repUntil: RepeatUntil, shouldDependOnIo: Option[Boolean]): Unit = {
+    typeProvider._currentIteratorType = Some(dataType)
+    if (shouldDependOnIo.map(shouldDepend => userExprDependsOnIo(repUntil.expr) != shouldDepend).getOrElse(false))
+      return
+    handleAssignmentTempVar(
+      dataType,
+      translator.doName(Identifier.ITERATOR),
+      translator.translate(itemExpr(id, repUntil))
+    )
+    attrAssertEqual(
+      repUntil.expr,
+      Ast.expr.Compare(
+        Ast.expr.Name(Ast.identifier(Identifier.INDEX)),
+        Ast.cmpop.Eq,
+        Ast.expr.BinOp(exprArraySize(Ast.expr.InternalName(id)), Ast.operator.Sub, Ast.expr.IntNum(1))
+      ),
+      idToMsg(id)
+    )
+  }
+
+  def attrIsEofCheck(id: Identifier, expectedIsEof: Boolean, io: String): Unit =
+    attrIsEofCheck(io, expectedIsEof, idToMsg(id))
+
+  def attrIsEofCheck(io: String, expectedIsEof: Boolean, msg: String): Unit
+
+  def attrParentParamCheck(id: Identifier, actualParentExpr: Ast.expr, ut: UserType, shouldDependOnIo: Option[Boolean]): Unit =
+    attrParentParamCheck(actualParentExpr, ut, shouldDependOnIo, idToMsg(id))
+
+  def attrParentParamCheck(actualParentExpr: Ast.expr, ut: UserType, shouldDependOnIo: Option[Boolean], msg: String): Unit
+
+  def attrAssertEqual(actual: Ast.expr, expected: Ast.expr, msg: String): Unit =
+    attrAssertCmp(actual, Ast.cmpop.NotEq, expected, msg)
+
+  def attrAssertLtE(actual: Ast.expr, expected: Ast.expr, msg: String): Unit =
+    attrAssertCmp(actual, Ast.cmpop.Gt, expected, msg)
+
+  def attrAssertCmp(actual: Ast.expr, op: Ast.cmpop, expected: Ast.expr, msg: String): Unit =
+    attrBasicCheck(
+      Ast.expr.Compare(actual, op, expected),
+      actual,
+      expected,
+      msg
+    )
+}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/CommonReads.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/CommonReads.scala
index 0640b3af5..e67112906 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/CommonReads.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/CommonReads.scala
@@ -3,8 +3,11 @@ package io.kaitai.struct.languages.components
 import io.kaitai.struct.datatype._
 import io.kaitai.struct.exprlang.Ast
 import io.kaitai.struct.format._
+import io.kaitai.struct.translators.BaseTranslator
 
 trait CommonReads extends LanguageCompiler {
+  val translator: BaseTranslator
+
   override def attrParse(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit = {
     attrParseIfHeader(id, attr.cond.ifExpr)
 
@@ -88,6 +91,36 @@ trait CommonReads extends LanguageCompiler {
     }
   }
 
+  def itemExpr(id: Identifier, rep: RepeatSpec): Ast.expr = {
+    val astId = Ast.expr.InternalName(id)
+    rep match {
+      case NoRepeat =>
+        astId
+      case _ =>
+        Ast.expr.Subscript(
+          astId,
+          Ast.expr.Name(Ast.identifier(Identifier.INDEX))
+        )
+    }
+  }
+
+  def handleAssignment(id: Identifier, expr: String, rep: RepeatSpec, isRaw: Boolean): Unit = {
+    rep match {
+      case RepeatEos => handleAssignmentRepeatEos(id, expr)
+      case RepeatExpr(_) => handleAssignmentRepeatExpr(id, expr)
+      case RepeatUntil(_) => handleAssignmentRepeatUntil(id, expr, isRaw)
+      case NoRepeat => handleAssignmentSimple(id, expr)
+    }
+  }
+
+  def handleAssignmentRepeatEos(id: Identifier, expr: String): Unit
+
+  def handleAssignmentRepeatExpr(id: Identifier, expr: String): Unit
+
+  def handleAssignmentRepeatUntil(id: Identifier, expr: String, isRaw: Boolean): Unit
+
+  def handleAssignmentSimple(id: Identifier, expr: String): Unit
+
   def attrParse2(id: Identifier, dataType: DataType, io: String, rep: RepeatSpec, isRaw: Boolean, defEndian: Option[FixedEndian], assignType: Option[DataType] = None): Unit
 
   def attrDebugStart(attrId: Identifier, attrType: DataType, io: Option[String], repeat: RepeatSpec): Unit = {}
@@ -101,5 +134,5 @@ trait CommonReads extends LanguageCompiler {
     * @param attr attribute to run validations for
     */
   def attrValidateAll(attr: AttrLikeSpec) =
-    attr.valid.foreach(valid => attrValidate(attr.id, attr, valid))
+    attr.valid.foreach(valid => attrValidate(attr.id, attr, valid, true))
 }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/CommonWrites.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/CommonWrites.scala
new file mode 100644
index 000000000..91f16e919
--- /dev/null
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/CommonWrites.scala
@@ -0,0 +1,322 @@
+package io.kaitai.struct.languages.components
+
+import io.kaitai.struct.datatype.DataType.{BytesEosType, BytesLimitType, BytesTerminatedType, BytesType, EnumType, Int1Type, IntType, StrFromBytesType, StrType, SwitchType, UserType, UserTypeFromBytes, UserTypeInstream}
+import io.kaitai.struct.datatype.{BigEndian, CalcEndian, DataType, Endianness, FixedEndian, InheritedEndian, LittleEndian}
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format.{AttrLikeSpec, Identifier, InnerSizeIdentifier, NoRepeat, OuterSizeIdentifier, ParseInstanceSpec, ProcessExpr, RawIdentifier, RepeatEos, RepeatExpr, RepeatSpec, RepeatUntil}
+
+trait CommonWrites extends LanguageCompiler with GenericChecks with CommonReads with ObjectOrientedLanguage {
+  override def attrWrite(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit = {
+    val checksShouldDependOnIo: Option[Boolean] =
+      if (userExprDependsOnIo(attr.cond.ifExpr)) {
+        None
+      } else {
+        Some(true)
+      }
+
+    attrParseIfHeader(id, attr.cond.ifExpr)
+
+    // Manage IO & seeking for ParseInstances
+    val io = attr match {
+      case pis: ParseInstanceSpec =>
+        val io = pis.io match {
+          case None => normalIO
+          case Some(ex) => useIO(ex)
+        }
+        pis.pos.foreach { pos =>
+          pushPos(io)
+          seek(io, pos)
+        }
+        io
+      case _ =>
+        // no seeking required for sequence attributes
+        normalIO
+    }
+
+    defEndian match {
+      case Some(_: CalcEndian) | Some(InheritedEndian) =>
+        // FIXME: rename to indicate that it can be used for both parsing/writing
+        attrParseHybrid(
+          () => attrWrite0(id, attr, io, Some(LittleEndian), checksShouldDependOnIo),
+          () => attrWrite0(id, attr, io, Some(BigEndian), checksShouldDependOnIo)
+        )
+      case None =>
+        attrWrite0(id, attr, io, None, checksShouldDependOnIo)
+      case Some(fe: FixedEndian) =>
+        attrWrite0(id, attr, io, Some(fe), checksShouldDependOnIo)
+    }
+
+    attr match {
+      case pis: ParseInstanceSpec =>
+        // Restore position, if applicable
+        if (pis.pos.isDefined)
+          popPos(io)
+      case _ => // no seeking required for sequence attributes
+    }
+
+    attrParseIfFooter(attr.cond.ifExpr)
+  }
+
+  def attrWrite0(
+                  id: Identifier,
+                  attr: AttrLikeSpec,
+                  io: String,
+                  defEndian: Option[FixedEndian],
+                  checksShouldDependOnIo: Option[Boolean]
+                ): Unit = {
+    if (attr.cond.repeat != NoRepeat)
+      ExtraAttrs.forAttr(attr, this)
+        .filter(a => a.id.isInstanceOf[RawIdentifier])
+        .foreach(a => condRepeatInitAttr(a.id, a.dataType))
+    attr.cond.repeat match {
+      case RepeatEos =>
+      case RepeatExpr(repeatExpr: Ast.expr) =>
+        attrRepeatExprCheck(id, repeatExpr, checksShouldDependOnIo)
+      case RepeatUntil(untilExpr: Ast.expr) =>
+        if (checksShouldDependOnIo.map(shouldDepend => shouldDepend == false).getOrElse(true))
+          attrAssertUntilNotEmpty(id)
+      case NoRepeat =>
+    }
+    if (attr.cond.repeat != NoRepeat) {
+      condRepeatCommonHeader(id, io, attr.dataType)
+    }
+
+    /**
+     * attr.cond.repeat match {
+     * case RepeatEos =>
+     * attrIsEofCheck(id, false, io)
+     * case _ =>
+     * }
+     */
+    attrWrite2(id, attr.dataType, io, attr.cond.repeat, false, defEndian, checksShouldDependOnIo)
+    attr.cond.repeat match {
+      case repUntil: RepeatUntil =>
+        attrAssertUntilCond(id, attr.dataType, repUntil, checksShouldDependOnIo)
+      case _ =>
+    }
+    if (attr.cond.repeat != NoRepeat) {
+      condRepeatCommonFooter
+    }
+    attr.cond.repeat match {
+      case RepeatEos =>
+        attrIsEofCheck(id, true, io)
+      case _ =>
+    }
+  }
+
+  def attrWrite2(
+    id: Identifier,
+    dataType: DataType,
+    io: String,
+    rep: RepeatSpec,
+    isRaw: Boolean,
+    defEndian: Option[FixedEndian],
+    checksShouldDependOnIo: Option[Boolean],
+    exprTypeOpt: Option[DataType] = None
+  ): Unit = {
+    dataType match {
+      case t: UserType =>
+        attrUserTypeWrite(id, t, io, rep, isRaw, defEndian, checksShouldDependOnIo, exprTypeOpt)
+      case t: BytesType =>
+        attrBytesTypeWrite(id, t, io, rep, isRaw, checksShouldDependOnIo, exprTypeOpt)
+      case st: SwitchType =>
+        val isNullable = if (switchBytesOnlyAsRaw) {
+          st.isNullableSwitchRaw
+        } else {
+          st.isNullable
+        }
+
+        attrSwitchTypeWrite(id, st.on, st.cases, io, rep, defEndian, checksShouldDependOnIo, st.combinedType)
+      case t: StrFromBytesType =>
+        attrStrTypeWrite(id, t, io, rep, isRaw, checksShouldDependOnIo, exprTypeOpt)
+      case t: EnumType =>
+        val expr = itemExpr(id, rep)
+        val exprType = internalEnumIntType(t.basedOn)
+        attrPrimitiveWrite(io, Ast.expr.Attribute(expr, Ast.identifier("to_i")), t.basedOn, defEndian, Some(exprType))
+      case _ =>
+        val expr = itemExpr(id, rep)
+        attrPrimitiveWrite(io, expr, dataType, defEndian, exprTypeOpt)
+    }
+  }
+
+  def attrBytesTypeWrite(
+                          id: Identifier,
+                          t: BytesType,
+                          io: String,
+                          rep: RepeatSpec,
+                          isRaw: Boolean,
+                          checksShouldDependOnIo: Option[Boolean],
+                          exprTypeOpt: Option[DataType]
+                        ): Unit = {
+    val idToWrite = t.process match {
+      case Some(proc) =>
+        val rawId = RawIdentifier(id)
+        attrUnprocess(proc, id, rawId, rep, t, exprTypeOpt)
+        rawId
+      case None =>
+        id
+    }
+    val item = if (idToWrite.isInstanceOf[RawIdentifier] && rep != NoRepeat) {
+      // NOTE: This special handling isn't normally needed and one can just use
+      // `itemExpr(idToWrite, rep)` as usual. The `itemExpr` method assumes that the
+      // expression it's supposed to generate will be used in a loop where the iteration
+      // variable `Identifier.INDEX` is available (usually called just `i`) and uses it. This
+      // is a good default, but it doesn't work if the expression is used between
+      // `subIOWriteBackHeader` and `subIOWriteBackFooter` (see `attrUserTypeWrite` below),
+      // because in Java the loop control variable `i` is not "final" or "effectively final".
+      //
+      // The workaround is to change the expression so that it doesn't depend on the `i`
+      // variable. We can do that here, because the `RawIdentifier(...)` array starts empty
+      // before the loop and each element is added by `attrUnprocess` in each loop iteration -
+      // so the current item is just the last entry in the `RawIdentifier(...)` array.
+      //
+      // See test ProcessRepeatUsertype that requires this.
+      val astId = Ast.expr.InternalName(idToWrite)
+      Ast.expr.Subscript(
+        astId,
+        Ast.expr.BinOp(
+          Ast.expr.Attribute(
+            astId,
+            Ast.identifier("size")
+          ),
+          Ast.operator.Sub,
+          Ast.expr.IntNum(1)
+        )
+      )
+    } else {
+      itemExpr(idToWrite, rep)
+    }
+    val itemBytes =
+      if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[BytesType]).getOrElse(false))
+        Ast.expr.CastToType(item, Ast.typeId(false, Seq("bytes")))
+      else
+        item
+    attrBytesTypeWrite2(id, io, itemBytes, t, checksShouldDependOnIo, exprTypeOpt)
+  }
+
+  def attrStrTypeWrite(
+                        id: Identifier,
+                        t: StrFromBytesType,
+                        io: String,
+                        rep: RepeatSpec,
+                        isRaw: Boolean,
+                        checksShouldDependOnIo: Option[Boolean],
+                        exprTypeOpt: Option[DataType]
+                      ): Unit = {
+    val item = itemExpr(id, rep)
+    val itemStr =
+      if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[StrType]).getOrElse(false))
+        Ast.expr.CastToType(item, Ast.typeId(false, Seq("str")))
+      else
+        item
+    val bytes = exprStrToBytes(itemStr, t.encoding)
+    attrBytesTypeWrite2(id, io, bytes, t.bytes, checksShouldDependOnIo, exprTypeOpt)
+  }
+
+  def attrBytesTypeWrite2(
+                           id: Identifier,
+                           io: String,
+                           expr: Ast.expr,
+                           t: BytesType,
+                           checksShouldDependOnIo: Option[Boolean],
+                           exprTypeOpt: Option[DataType]
+                         ): Unit = {
+    attrBytesCheck(id, expr, t, checksShouldDependOnIo)
+    t match {
+      case bt: BytesEosType =>
+        attrBytesLimitWrite2(io, expr, bt, exprIORemainingSize(io), bt.padRight, bt.terminator, bt.include, exprTypeOpt)
+        attrIsEofCheck(id, true, io)
+      case bt: BytesLimitType =>
+        attrBytesLimitWrite2(io, expr, bt, expression(bt.size), bt.padRight, bt.terminator, bt.include, exprTypeOpt)
+      case t: BytesTerminatedType =>
+        attrPrimitiveWrite(io, expr, t, None, exprTypeOpt)
+        if (t.include) {
+          val actualIndexOfTerm = exprByteArrayIndexOf(expr, t.terminator)
+          if (!t.eosError) {
+            condIfHeader(Ast.expr.Compare(actualIndexOfTerm, Ast.cmpop.Eq, Ast.expr.IntNum(-1)))
+            attrIsEofCheck(id, true, io)
+            condIfFooter
+          }
+        } else {
+          if (!t.eosError)
+            condIfIsEofHeader(io, false)
+
+          if (!t.consume) {
+            if (t.eosError) {
+              blockScopeHeader
+            }
+            pushPos(io)
+          }
+          attrPrimitiveWrite(io, Ast.expr.IntNum(t.terminator), Int1Type(false), None, None)
+          if (!t.consume) {
+            popPos(io)
+            if (t.eosError) {
+              blockScopeFooter
+            }
+          }
+          if (!t.eosError)
+            condIfIsEofFooter
+        }
+    }
+  }
+
+  def attrBytesLimitWrite2(
+      io: String,
+      expr: Ast.expr,
+      bt: BytesType,
+      sizeExpr: String,
+      padRight: Option[Int],
+      terminator: Option[Int],
+      include: Boolean,
+      exprTypeOpt: Option[DataType]
+    ): Unit = {
+    val (termArg, padRightArg) = (terminator, padRight, include) match {
+      case (None, None, false) =>
+        // no terminator, no padding => just a regular output
+        // validation should check that expression's length matches size
+        attrPrimitiveWrite(io, expr, bt, None, exprTypeOpt)
+        return
+      case (_, None, true) =>
+        // terminator included, no padding => pad with zeroes
+        (0, 0)
+      case (_, Some(p), true) =>
+        // terminator included, padding specified
+        (p, p)
+      case (Some(t), None, false) =>
+        // only terminator given, don't care about what's gonna go after that
+        // we'll just pad with zeroes
+        (t, 0)
+      case (None, Some(p), false) =>
+        // only padding given, just add terminator equal to padding
+        (p, p)
+      case (Some(t), Some(p), false) =>
+        // both terminator and padding specified
+        (t, p)
+    }
+    attrBytesLimitWrite(io, expr, sizeExpr, termArg, padRightArg)
+  }
+
+  def attrUserTypeWrite(id: Identifier, t: UserType, io: String, rep: RepeatSpec, isRaw: Boolean, defEndian: Option[FixedEndian], checksShouldDependOnIo: Option[Boolean], exprTypeOpt: Option[DataType] = None): Unit
+
+  def internalEnumIntType(basedOn: IntType): DataType
+
+  def attrPrimitiveWrite(io: String, expr: Ast.expr, dt: DataType, defEndian: Option[FixedEndian], exprTypeOpt: Option[DataType]): Unit
+
+  def attrBytesLimitWrite(io: String, expr: Ast.expr, size: String, term: Int, padRight: Int): Unit
+
+  def attrUserTypeInstreamWrite(io: String, expr: Ast.expr, t: DataType, exprType: DataType): Unit
+
+  def exprStreamToByteArray(ioFixed: String): String
+
+  def attrUnprocess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec, dt: BytesType, exprTypeOpt: Option[DataType]): Unit
+
+  def attrUnprocessPrepareBeforeSubIOHandler(proc: ProcessExpr, varSrc: Identifier): Unit
+
+  def condIfIsEofHeader(io: String, wantedIsEof: Boolean): Unit
+
+  def condIfIsEofFooter: Unit
+
+  def attrSetProperty(base: Ast.expr, propName: Identifier, value: String): Unit
+
+  def attrSwitchTypeWrite(id: Identifier, on: Ast.expr, cases: Map[Ast.expr, DataType], io: String, rep: RepeatSpec, defEndian: Option[FixedEndian], checksShouldDependOnIoOrig: Option[Boolean], assignType: DataType): Unit
+}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/EveryReadIsExpression.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/EveryReadIsExpression.scala
index 1bc427c6f..50a79227c 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/EveryReadIsExpression.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/EveryReadIsExpression.scala
@@ -186,6 +186,36 @@ trait EveryReadIsExpression
 
     attrParse2(rawId, byteType, io, rep, true, defEndian)
 
+    if (config.readWrite) {
+      if (writeNeedsOuterSize(byteType)) {
+        /** @note Must be kept in sync with [[attrBytesTypeParse]] */
+        val rawRawId = byteType.process match {
+          case None => rawId
+          case Some(_) => RawIdentifier(rawId)
+        }
+        val item = itemExpr(rawRawId, rep)
+        val itemSizeExprStr = expression(Ast.expr.Attribute(item, Ast.identifier("size")))
+        /** FIXME: cannot use [[handleAssignment]] because [[handleAssignmentRepeatUntil]]
+         * always tries to assign the value to the [[Identifier.ITERATOR]] variable */
+        if (rep == NoRepeat) {
+          handleAssignmentSimple(OuterSizeIdentifier(id), itemSizeExprStr)
+        } else {
+          handleAssignmentRepeatEos(OuterSizeIdentifier(id), itemSizeExprStr)
+        }
+      }
+      if (writeNeedsInnerSize(byteType)) {
+        val item = itemExpr(rawId, rep)
+        val itemSizeExprStr = expression(Ast.expr.Attribute(item, Ast.identifier("size")))
+        /** FIXME: cannot use [[handleAssignment]] because [[handleAssignmentRepeatUntil]]
+         * always tries to assign the value to the [[Identifier.ITERATOR]] variable */
+        if (rep == NoRepeat) {
+          handleAssignmentSimple(InnerSizeIdentifier(id), itemSizeExprStr)
+        } else {
+          handleAssignmentRepeatEos(InnerSizeIdentifier(id), itemSizeExprStr)
+        }
+      }
+    }
+
     val extraType = rep match {
       case NoRepeat => byteType
       case _ => ArrayTypeInStream(byteType)
@@ -231,19 +261,7 @@ trait EveryReadIsExpression
     )
   }
 
-  def handleAssignment(id: Identifier, expr: String, rep: RepeatSpec, isRaw: Boolean): Unit = {
-    rep match {
-      case RepeatEos => handleAssignmentRepeatEos(id, expr)
-      case RepeatExpr(_) => handleAssignmentRepeatExpr(id, expr)
-      case RepeatUntil(_) => handleAssignmentRepeatUntil(id, expr, isRaw)
-      case NoRepeat => handleAssignmentSimple(id, expr)
-    }
-  }
 
-  def handleAssignmentRepeatEos(id: Identifier, expr: String): Unit
-  def handleAssignmentRepeatExpr(id: Identifier, expr: String): Unit
-  def handleAssignmentRepeatUntil(id: Identifier, expr: String, isRaw: Boolean): Unit
-  def handleAssignmentSimple(id: Identifier, expr: String): Unit
   def handleAssignmentTempVar(dataType: DataType, id: String, expr: String): Unit = ???
 
   def parseExpr(dataType: DataType, assignType: DataType, io: String, defEndian: Option[FixedEndian]): String
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/EveryWriteIsExpression.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/EveryWriteIsExpression.scala
new file mode 100644
index 000000000..dec964d13
--- /dev/null
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/EveryWriteIsExpression.scala
@@ -0,0 +1,449 @@
+package io.kaitai.struct.languages.components
+
+import io.kaitai.struct.datatype.DataType
+import io.kaitai.struct.datatype.DataType._
+import io.kaitai.struct.datatype.FixedEndian
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format._
+
+import scala.collection.mutable.ListBuffer
+import io.kaitai.struct.datatype._
+
+trait EveryWriteIsExpression
+  extends LanguageCompiler
+    with ObjectOrientedLanguage
+    with EveryReadIsExpression
+    with GenericChecks {
+  override def attrWrite(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit = {
+    val checksShouldDependOnIo: Option[Boolean] =
+      if (userExprDependsOnIo(attr.cond.ifExpr)) {
+        None
+      } else {
+        Some(true)
+      }
+
+    attrParseIfHeader(id, attr.cond.ifExpr)
+
+    // Manage IO & seeking for ParseInstances
+    val io = attr match {
+      case pis: ParseInstanceSpec =>
+        val io = pis.io match {
+          case None => normalIO
+          case Some(ex) => useIO(ex)
+        }
+        pis.pos.foreach { pos =>
+          pushPos(io)
+          seek(io, pos)
+        }
+        io
+      case _ =>
+        // no seeking required for sequence attributes
+        normalIO
+    }
+
+    defEndian match {
+      case Some(_: CalcEndian) | Some(InheritedEndian) =>
+        // FIXME: rename to indicate that it can be used for both parsing/writing
+        attrParseHybrid(
+          () => attrWrite0(id, attr, io, Some(LittleEndian), checksShouldDependOnIo),
+          () => attrWrite0(id, attr, io, Some(BigEndian), checksShouldDependOnIo)
+        )
+      case None =>
+        attrWrite0(id, attr, io, None, checksShouldDependOnIo)
+      case Some(fe: FixedEndian) =>
+        attrWrite0(id, attr, io, Some(fe), checksShouldDependOnIo)
+    }
+
+    attr match {
+      case pis: ParseInstanceSpec =>
+        // Restore position, if applicable
+        if (pis.pos.isDefined)
+          popPos(io)
+      case _ => // no seeking required for sequence attributes
+    }
+
+    attrParseIfFooter(attr.cond.ifExpr)
+  }
+
+  def attrWrite0(
+    id: Identifier,
+    attr: AttrLikeSpec,
+    io: String,
+    defEndian: Option[FixedEndian],
+    checksShouldDependOnIo: Option[Boolean]
+  ): Unit = {
+    if (attr.cond.repeat != NoRepeat)
+      ExtraAttrs.forAttr(attr, this)
+        .filter(a => a.id.isInstanceOf[RawIdentifier])
+        .foreach(a => condRepeatInitAttr(a.id, a.dataType))
+    attr.cond.repeat match {
+      case RepeatEos =>
+      case RepeatExpr(repeatExpr: Ast.expr) =>
+        attrRepeatExprCheck(id, repeatExpr, checksShouldDependOnIo)
+      case RepeatUntil(untilExpr: Ast.expr) =>
+        if (checksShouldDependOnIo.map(shouldDepend => shouldDepend == false).getOrElse(true))
+          attrAssertUntilNotEmpty(id)
+      case NoRepeat =>
+    }
+    if (attr.cond.repeat != NoRepeat) {
+      condRepeatCommonHeader(id, io, attr.dataType)
+    }
+    attr.cond.repeat match {
+      case RepeatEos =>
+        attrIsEofCheck(id, false, io)
+      case _ =>
+    }
+    attrWrite2(id, attr.dataType, io, attr.cond.repeat, false, defEndian, checksShouldDependOnIo)
+    attr.cond.repeat match {
+      case repUntil: RepeatUntil =>
+        attrAssertUntilCond(id, attr.dataType, repUntil, checksShouldDependOnIo)
+      case _ =>
+    }
+    if (attr.cond.repeat != NoRepeat) {
+      condRepeatCommonFooter
+    }
+    attr.cond.repeat match {
+      case RepeatEos =>
+        attrIsEofCheck(id, true, io)
+      case _ =>
+    }
+  }
+
+  def attrWrite2(
+    id: Identifier,
+    dataType: DataType,
+    io: String,
+    rep: RepeatSpec,
+    isRaw: Boolean,
+    defEndian: Option[FixedEndian],
+    checksShouldDependOnIo: Option[Boolean],
+    exprTypeOpt: Option[DataType] = None
+  ): Unit = {
+    dataType match {
+      case t: UserType =>
+        attrUserTypeWrite(id, t, io, rep, isRaw, defEndian, checksShouldDependOnIo, exprTypeOpt)
+      case t: BytesType =>
+        attrBytesTypeWrite(id, t, io, rep, isRaw, checksShouldDependOnIo, exprTypeOpt)
+      case st: SwitchType =>
+        val isNullable = if (switchBytesOnlyAsRaw) {
+          st.isNullableSwitchRaw
+        } else {
+          st.isNullable
+        }
+
+        attrSwitchTypeWrite(id, st.on, st.cases, io, rep, defEndian, checksShouldDependOnIo, st.combinedType)
+      case t: StrFromBytesType =>
+        attrStrTypeWrite(id, t, io, rep, isRaw, checksShouldDependOnIo, exprTypeOpt)
+      case t: EnumType =>
+        val expr = itemExpr(id, rep)
+        val exprType = internalEnumIntType(t.basedOn)
+        attrPrimitiveWrite(io, Ast.expr.Attribute(expr, Ast.identifier("to_i")), t.basedOn, defEndian, Some(exprType))
+      case _ =>
+        val expr = itemExpr(id, rep)
+        attrPrimitiveWrite(io, expr, dataType, defEndian, exprTypeOpt)
+    }
+  }
+
+  def attrBytesTypeWrite(
+    id: Identifier,
+    t: BytesType,
+    io: String,
+    rep: RepeatSpec,
+    isRaw: Boolean,
+    checksShouldDependOnIo: Option[Boolean],
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    val idToWrite = t.process match {
+      case Some(proc) =>
+        val rawId = RawIdentifier(id)
+        attrUnprocess(proc, id, rawId, rep, t, exprTypeOpt)
+        rawId
+      case None =>
+        id
+    }
+    val item = if (idToWrite.isInstanceOf[RawIdentifier] && rep != NoRepeat) {
+      // NOTE: This special handling isn't normally needed and one can just use
+      // `itemExpr(idToWrite, rep)` as usual. The `itemExpr` method assumes that the
+      // expression it's supposed to generate will be used in a loop where the iteration
+      // variable `Identifier.INDEX` is available (usually called just `i`) and uses it. This
+      // is a good default, but it doesn't work if the expression is used between
+      // `subIOWriteBackHeader` and `subIOWriteBackFooter` (see `attrUserTypeWrite` below),
+      // because in Java the loop control variable `i` is not "final" or "effectively final".
+      //
+      // The workaround is to change the expression so that it doesn't depend on the `i`
+      // variable. We can do that here, because the `RawIdentifier(...)` array starts empty
+      // before the loop and each element is added by `attrUnprocess` in each loop iteration -
+      // so the current item is just the last entry in the `RawIdentifier(...)` array.
+      //
+      // See test ProcessRepeatUsertype that requires this.
+      val astId = Ast.expr.InternalName(idToWrite)
+      Ast.expr.Subscript(
+        astId,
+        Ast.expr.BinOp(
+          Ast.expr.Attribute(
+            astId,
+            Ast.identifier("size")
+          ),
+          Ast.operator.Sub,
+          Ast.expr.IntNum(1)
+        )
+      )
+    } else {
+      itemExpr(idToWrite, rep)
+    }
+    val itemBytes =
+      if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[BytesType]).getOrElse(false))
+        Ast.expr.CastToType(item, Ast.typeId(false, Seq("bytes")))
+      else
+        item
+    attrBytesTypeWrite2(id, io, itemBytes, t, checksShouldDependOnIo, exprTypeOpt)
+  }
+
+  def attrStrTypeWrite(
+    id: Identifier,
+    t: StrFromBytesType,
+    io: String,
+    rep: RepeatSpec,
+    isRaw: Boolean,
+    checksShouldDependOnIo: Option[Boolean],
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    val item = itemExpr(id, rep)
+    val itemStr =
+      if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[StrType]).getOrElse(false))
+        Ast.expr.CastToType(item, Ast.typeId(false, Seq("str")))
+      else
+        item
+    val bytes = exprStrToBytes(itemStr, t.encoding)
+    attrBytesTypeWrite2(id, io, bytes, t.bytes, checksShouldDependOnIo, exprTypeOpt)
+  }
+
+  def attrBytesTypeWrite2(
+    id: Identifier,
+    io: String,
+    expr: Ast.expr,
+    t: BytesType,
+    checksShouldDependOnIo: Option[Boolean],
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    attrBytesCheck(id, expr, t, checksShouldDependOnIo)
+    t match {
+      case bt: BytesEosType =>
+        attrBytesLimitWrite2(io, expr, bt, exprIORemainingSize(io), bt.padRight, bt.terminator, bt.include, exprTypeOpt)
+        attrIsEofCheck(id, true, io)
+      case bt: BytesLimitType =>
+        attrBytesLimitWrite2(io, expr, bt, expression(bt.size), bt.padRight, bt.terminator, bt.include, exprTypeOpt)
+      case t: BytesTerminatedType =>
+        attrPrimitiveWrite(io, expr, t, None, exprTypeOpt)
+        if (t.include) {
+          val actualIndexOfTerm = exprByteArrayIndexOf(expr, t.terminator)
+          if (!t.eosError) {
+            condIfHeader(Ast.expr.Compare(actualIndexOfTerm, Ast.cmpop.Eq, Ast.expr.IntNum(-1)))
+            attrIsEofCheck(id, true, io)
+            condIfFooter
+          }
+        } else {
+          if (!t.eosError)
+            condIfIsEofHeader(io, false)
+
+          if (!t.consume) {
+            if (t.eosError) {
+              blockScopeHeader
+            }
+            pushPos(io)
+          }
+          attrPrimitiveWrite(io, Ast.expr.IntNum(t.terminator), Int1Type(false), None, None)
+          if (!t.consume) {
+            popPos(io)
+            if (t.eosError) {
+              blockScopeFooter
+            }
+          }
+          if (!t.eosError)
+            condIfIsEofFooter
+        }
+    }
+  }
+
+  def attrBytesLimitWrite2(
+    io: String,
+    expr: Ast.expr,
+    bt: BytesType,
+    sizeExpr: String,
+    padRight: Option[Int],
+    terminator: Option[Int],
+    include: Boolean,
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    val (termArg, padRightArg) = (terminator, padRight, include) match {
+      case (None, None, false) =>
+        // no terminator, no padding => just a regular output
+        // validation should check that expression's length matches size
+        attrPrimitiveWrite(io, expr, bt, None, exprTypeOpt)
+        return
+      case (_, None, true) =>
+        // terminator included, no padding => pad with zeroes
+        (0, 0)
+      case (_, Some(p), true) =>
+        // terminator included, padding specified
+        (p, p)
+      case (Some(t), None, false) =>
+        // only terminator given, don't care about what's gonna go after that
+        // we'll just pad with zeroes
+        (t, 0)
+      case (None, Some(p), false) =>
+        // only padding given, just add terminator equal to padding
+        (p, p)
+      case (Some(t), Some(p), false) =>
+        // both terminator and padding specified
+        (t, p)
+    }
+    attrBytesLimitWrite(io, expr, sizeExpr, termArg, padRightArg)
+  }
+
+  def attrUserTypeWrite(
+    id: Identifier,
+    t: UserType,
+    io: String,
+    rep: RepeatSpec,
+    isRaw: Boolean,
+    defEndian: Option[FixedEndian],
+    checksShouldDependOnIo: Option[Boolean],
+    exprTypeOpt: Option[DataType] = None
+  ) = {
+    val exprType = exprTypeOpt.getOrElse(t)
+    val expr = itemExpr(id, rep)
+
+    {
+      val itemUserType =
+        if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[UserType]).getOrElse(false))
+          Ast.expr.CastToType(expr, Ast.typeId(true, t.classSpec.get.name))
+        else
+          expr
+      // check non-`io` params
+      attrUserTypeCheck(id, itemUserType, t, checksShouldDependOnIo)
+      // set `io` params
+      (t.classSpec.get.params, t.args).zipped.foreach { (paramDef, argExpr) =>
+        val paramItemType = getArrayItemType(paramDef.dataType)
+        val paramBasedOnIo = (paramItemType == KaitaiStreamType || paramItemType == OwnedKaitaiStreamType)
+        if (paramBasedOnIo)
+          attrSetProperty(itemUserType, paramDef.id, expression(argExpr))
+      }
+    }
+
+    t match {
+      case _: UserTypeInstream =>
+        attrUserTypeInstreamWrite(io, expr, t, exprType)
+      case utb: UserTypeFromBytes =>
+        val rawId = RawIdentifier(id)
+        val byteType = utb.bytes
+
+        /** @note Must be kept in sync with [[ExtraAttrs.writeNeedsOuterSize]] */
+        val outerSize = byteType match {
+          case blt: BytesLimitType =>
+            translator.translate(blt.size)
+          case _: BytesEosType =>
+            exprIORemainingSize(io)
+          case _: BytesTerminatedType =>
+            translator.translate(itemExpr(OuterSizeIdentifier(id), rep))
+        }
+
+        /** @note Must be kept in sync with [[ExtraAttrs.writeNeedsInnerSize]] */
+        val innerSize = if (writeNeedsInnerSize(utb.bytes)) {
+          translator.translate(itemExpr(InnerSizeIdentifier(id), rep))
+        } else {
+          outerSize
+        }
+
+        this match {
+          //      case thisStore: AllocateAndStoreIO =>
+          //        val ourIO = thisStore.allocateIO(rawId, rep)
+          //        Utils.addUniqueAttr(extraAttrs, AttrSpec(List(), ourIO, KaitaiStreamType))
+          //        privateMemberName(ourIO)
+          case thisLocal: AllocateIOLocalVar =>
+            val ioFixed = thisLocal.allocateIOFixed(rawId, innerSize)
+            addChildIO(io, ioFixed)
+
+            blockScopeHeader
+
+            pushPosForSubIOWriteBackHandler(io)
+            seekRelative(io, outerSize)
+            byteType match {
+              case t: BytesTerminatedType =>
+                if (!t.include && t.consume) {
+                  if (!t.eosError)
+                    condIfIsEofHeader(io, false)
+                  // terminator can only be 1 byte long at the moment
+                  seekRelative(io, expression(Ast.expr.IntNum(1)))
+                  if (!t.eosError)
+                    condIfIsEofFooter
+                }
+              case _ => // do nothing
+            }
+
+            byteType.process.foreach { (process) =>
+              attrUnprocessPrepareBeforeSubIOHandler(process, rawId)
+            }
+
+            {
+              val parentIO = subIOWriteBackHeader(ioFixed, byteType.process)
+              handleAssignment(rawId, exprStreamToByteArray(ioFixed), rep, true)
+              attrBytesTypeWrite(rawId, byteType, parentIO, rep, isRaw, None, exprTypeOpt)
+              subIOWriteBackFooter(ioFixed)
+            }
+
+            blockScopeFooter
+
+            attrUserTypeInstreamWrite(ioFixed, expr, t, exprType)
+        }
+    }
+  }
+  def attrSwitchTypeWrite(
+    id: Identifier,
+    on: Ast.expr,
+    cases: Map[Ast.expr, DataType],
+    io: String,
+    rep: RepeatSpec,
+    defEndian: Option[FixedEndian],
+    checksShouldDependOnIoOrig: Option[Boolean],
+    assignType: DataType
+  ): Unit = {
+    val checksShouldDependOnIo =
+      if (userExprDependsOnIo(on)) {
+        None
+      } else {
+        checksShouldDependOnIoOrig
+      }
+
+    switchCases[DataType](id, on, cases,
+      (dataType) => {
+        attrWrite2(id, dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+      },
+      (dataType) => if (switchBytesOnlyAsRaw) {
+        dataType match {
+          case t: BytesType =>
+            attrWrite2(RawIdentifier(id), dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+          case _ =>
+            attrWrite2(id, dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+        }
+      } else {
+        attrWrite2(id, dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+      }
+    )
+  }
+
+  def internalEnumIntType(basedOn: IntType): DataType
+
+  def attrPrimitiveWrite(io: String, expr: Ast.expr, dt: DataType, defEndian: Option[FixedEndian], exprTypeOpt: Option[DataType]): Unit
+  def attrBytesLimitWrite(io: String, expr: Ast.expr, size: String, term: Int, padRight: Int): Unit
+  def attrUserTypeInstreamWrite(io: String, expr: Ast.expr, t: DataType, exprType: DataType): Unit
+  def exprStreamToByteArray(ioFixed: String): String
+
+  def attrUnprocess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec, dt: BytesType, exprTypeOpt: Option[DataType]): Unit
+  def attrUnprocessPrepareBeforeSubIOHandler(proc: ProcessExpr, varSrc: Identifier): Unit
+
+  def condIfIsEofHeader(io: String, wantedIsEof: Boolean): Unit
+  def condIfIsEofFooter: Unit
+
+  def attrSetProperty(base: Ast.expr, propName: Identifier, value: String): Unit
+}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/ExtraAttrs.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/ExtraAttrs.scala
index 2799bb53e..487bfa45e 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/ExtraAttrs.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/ExtraAttrs.scala
@@ -3,12 +3,15 @@ package io.kaitai.struct.languages.components
 import io.kaitai.struct.datatype.DataType
 import io.kaitai.struct.datatype.DataType._
 import io.kaitai.struct.format._
+import io.kaitai.struct.RuntimeConfig
 
 /**
   * Trait to be implemented by all [[LanguageCompiler]] compilers: supplies extra attributes
   * when we'll be allocating new IOs.
   */
 trait ExtraAttrs {
+  val config: RuntimeConfig
+
   /**
     * Provides a collection of extra attributes which will be necessary to store in a class for
     * handling of a single "normal" attribute. Primarily
@@ -29,8 +32,24 @@ trait ExtraAttrs {
         }
       case utb: UserTypeFromBytes =>
         // User type in a substream
+        val dynamicSizeAttributes: List[AttrSpec] = if (config.readWrite) {
+          val outerSizeOpt: Option[AttrSpec] = if (writeNeedsOuterSize(utb.bytes)) {
+            Some(AttrSpec(List(), OuterSizeIdentifier(id), CalcIntType, condSpec))
+          } else {
+            None
+          }
+          val innerSizeOpt: Option[AttrSpec] = if (writeNeedsInnerSize(utb.bytes)) {
+            Some(AttrSpec(List(), InnerSizeIdentifier(id), CalcIntType, condSpec))
+          } else {
+            None
+          }
+          List(innerSizeOpt, outerSizeOpt).flatten
+        } else {
+          List()
+        }
         val rawId = RawIdentifier(id)
         (extraRawAttrForUserTypeFromBytes(id, utb, condSpec) ++
+          dynamicSizeAttributes ++
           extraAttrForIO(rawId, condSpec.repeat) ++
           extraAttrsForAttribute(rawId, utb.bytes, condSpec)).toList.distinct
       case st: SwitchType =>
@@ -59,15 +78,39 @@ trait ExtraAttrs {
     List(AttrSpec(List(), RawIdentifier(id), ut.bytes, condSpec))
 
   def extraAttrForIO(id: Identifier, rep: RepeatSpec): List[AttrSpec]
+  def writeNeedsOuterSize(bytes: BytesType): Boolean = {
+    bytes match {
+      case _: BytesTerminatedType => true
+      case _ => false
+    }
+  }
+  def writeNeedsInnerSize(bytes: BytesType): Boolean = {
+    val unknownInnerSizeProcess = bytes.process match {
+      case Some(process) => process match {
+        case ProcessZlib | _: ProcessCustom => true
+        case _: ProcessXor | _: ProcessRotate => false
+      }
+      case None => false
+    }
+    val unknownInnerSizePadTerm = bytes match {
+      case bt: BytesLimitType =>
+        bt.padRight.isDefined || bt.terminator.isDefined
+      case bt: BytesEosType =>
+        bt.padRight.isDefined || bt.terminator.isDefined
+      case _ => false
+    }
+    unknownInnerSizeProcess || unknownInnerSizePadTerm
+  }
 }
 
 /**
   * Generates list of extra attributes required to store intermediate /
   * virtual stuff for every attribute like:
   *
-  * * buffered raw value byte arrays
-  * * IO objects (?)
-  * * unprocessed / postprocessed byte arrays
+  * - buffered raw value byte arrays
+  * - IO objects (?)
+  * - unprocessed / postprocessed byte arrays
+  * - outer and inner sizes of fields with substreams
   */
 object ExtraAttrs {
   def forClassSpec(curClass: ClassSpec, compiler: ExtraAttrs): List[AttrSpec] = {
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/FetchInstances.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/FetchInstances.scala
new file mode 100644
index 000000000..d1135041c
--- /dev/null
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/FetchInstances.scala
@@ -0,0 +1,53 @@
+package io.kaitai.struct.languages.components
+
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format._
+import io.kaitai.struct.datatype.DataType
+import io.kaitai.struct.datatype.DataType._
+
+trait FetchInstances extends LanguageCompiler with ObjectOrientedLanguage with CommonReads {
+  override def attrFetchInstances(attr: AttrLikeSpec, id: Identifier): Unit = {
+    attrParseIfHeader(id, attr.cond.ifExpr)
+
+    val io = normalIO
+
+    id match {
+      case instName: InstanceIdentifier =>
+        attrInvokeInstance(instName)
+      case _ =>
+    }
+
+    if (attr.cond.repeat != NoRepeat)
+      condRepeatCommonHeader(id, io, attr.dataType)
+
+    attrFetchInstances2(id, attr.dataType, attr.cond.repeat)
+
+    if (attr.cond.repeat != NoRepeat)
+      condRepeatCommonFooter
+
+    attrParseIfFooter(attr.cond.ifExpr)
+  }
+
+  def attrFetchInstances2(id: Identifier, dataType: DataType, rep: RepeatSpec, exprTypeOpt: Option[DataType] = None): Unit = {
+    dataType match {
+      case _: UserType =>
+        val exprType = exprTypeOpt.getOrElse(dataType)
+        attrInvokeFetchInstances(itemExpr(id, rep), exprType, dataType)
+      case st: SwitchType =>
+        attrSwitchTypeFetchInstances(id, st.on, st.cases, rep, st.combinedType)
+      case _ =>
+    }
+  }
+
+  def attrSwitchTypeFetchInstances(id: Identifier, on: Ast.expr, cases: Map[Ast.expr, DataType], rep: RepeatSpec, assignType: DataType): Unit = {
+    switchCases[DataType](id, on, cases,
+      (dataType) => {
+        attrFetchInstances2(id, dataType, rep, Some(assignType))
+      },
+      (dataType) => {
+        // TODO: process switchBytesOnlyAsRaw
+        attrFetchInstances2(id, dataType, rep, Some(assignType))
+      }
+    )
+  }
+}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/FixedContentsUsingArrayByteLiteral.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/FixedContentsUsingArrayByteLiteral.scala
deleted file mode 100644
index c5d4abd9b..000000000
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/FixedContentsUsingArrayByteLiteral.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-package io.kaitai.struct.languages.components
-
-import io.kaitai.struct.exprlang.Ast
-import io.kaitai.struct.format.Identifier
-
-/**
-  * Allows uniform implementation of attrFixedContentsParse by enforcing usage
-  * of doByteArrayLiteral in relevant language's translator.
-  */
-trait FixedContentsUsingArrayByteLiteral extends LanguageCompiler {
-  def attrFixedContentsParse(attrName: Identifier, contents: Array[Byte]) =
-    attrFixedContentsParse(
-      attrName,
-      translator.translate(
-        Ast.expr.List(
-          contents.map(x => Ast.expr.IntNum(BigInt(x & 0xff)))
-        )
-      )
-    )
-  def attrFixedContentsParse(attrName: Identifier, contents: String): Unit
-}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/GenericChecks.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/GenericChecks.scala
new file mode 100644
index 000000000..f8b3ec4bc
--- /dev/null
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/GenericChecks.scala
@@ -0,0 +1,39 @@
+package io.kaitai.struct.languages.components
+
+import io.kaitai.struct.datatype.DataType
+import io.kaitai.struct.datatype.DataType._
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format._
+
+trait GenericChecks extends CommonChecks with CommonReads {
+   override def attrCheck2(id: Identifier, dataType: DataType, repeat: RepeatSpec, shouldDependOnIo: Option[Boolean], exprTypeOpt: Option[DataType] = None) = {
+    val item = itemExpr(id, repeat)
+    dataType match {
+      case ut: UserType =>
+        val itemUserType =
+          if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[UserType]).getOrElse(false))
+            Ast.expr.CastToType(item, Ast.typeId(true, ut.classSpec.get.name))
+          else
+            item
+        attrUserTypeCheck(id, itemUserType, ut, shouldDependOnIo)
+      case t: BytesType =>
+        val itemBytes =
+          if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[BytesType]).getOrElse(false))
+            Ast.expr.CastToType(item, Ast.typeId(false, Seq("bytes")))
+          else
+            item
+        attrBytesCheck(id, itemBytes, t, shouldDependOnIo)
+      case st: StrFromBytesType =>
+        val itemStr =
+          if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[StrType]).getOrElse(false))
+            Ast.expr.CastToType(item, Ast.typeId(false, Seq("str")))
+          else
+            item
+        val bytes = exprStrToBytes(itemStr, st.encoding)
+        attrBytesCheck(id, bytes, st.bytes, shouldDependOnIo)
+      case st: SwitchType =>
+        attrSwitchCheck(id, st.on, st.cases, repeat, shouldDependOnIo, st.combinedType)
+      case _ => // no checks
+    }
+  }
+}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/GoReads.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/GoReads.scala
index 600d0cb28..5c9dfbbd9 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/GoReads.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/GoReads.scala
@@ -4,11 +4,27 @@ import io.kaitai.struct.datatype.DataType._
 import io.kaitai.struct.datatype.{DataType, FixedEndian}
 import io.kaitai.struct.exprlang.Ast
 import io.kaitai.struct.format._
-import io.kaitai.struct.translators.{GoTranslator, ResultLocalVar, ResultString, TranslatorResult}
+import io.kaitai.struct.translators.GoTranslator
 
 trait GoReads extends CommonReads with ObjectOrientedLanguage with GoSwitchOps {
   val translator: GoTranslator
 
+  def attrRawBytesTypeParse(
+    id: Identifier, t: BytesTerminatedType, value: String
+  ): String = {
+    val rawId = t.process match {
+      case None => id
+      case Some(_) => RawIdentifier(id)
+    }
+    translator.terminatedConstructorFact(id, t, scala.collection.mutable.Map(
+      "terminator" -> t.terminator,
+      "include"    -> t.include,
+      "consume"    -> t.consume,
+      "eosError"   -> t.eosError,
+    ))
+    s"this.New_${idToStr(id)}TerminatedType($value)"
+  }
+
   def attrBytesTypeParse(
     id: Identifier,
     dataType: BytesType,
@@ -42,6 +58,7 @@ trait GoReads extends CommonReads with ObjectOrientedLanguage with GoSwitchOps {
       {
         case dataType@(t: BytesType) =>
           attrParse2(RawIdentifier(id), dataType, io, rep, false, defEndian, Some(assignType))
+          handleAssignment(id, translator.getNowLocalVarName(), rep, false)
         case dataType =>
           attrParse2(id, dataType, io, rep, false, defEndian, Some(assignType))
       }
@@ -60,23 +77,32 @@ trait GoReads extends CommonReads with ObjectOrientedLanguage with GoSwitchOps {
     dataType match {
       case t: UserType =>
         attrUserTypeParse(id, t, io, rep, defEndian)
+      case t: BytesTerminatedType =>
+        val rawId = t.process match {
+          case None => id
+          case Some(_) => RawIdentifier(id)
+        }
+        val r1 = parseExprBytes(translator.outVarCheckRes(parseExpr(t, io, defEndian)), t)
+        val expr = attrRawBytesTypeParse(id, t, r1)
+        handleAssignment(rawId, expr, rep, isRaw)
+        t.process.foreach((proc) => attrProcess(proc, rawId, id, rep))
       case t: BytesType =>
         attrBytesTypeParse(id, t, io, rep, isRaw)
       case st: SwitchType =>
         attrSwitchTypeParse(id, st.on, st.cases, io, rep, defEndian, st.isNullableSwitchRaw, st.combinedType)
       case t: StrFromBytesType =>
         val r1 = parseExprBytes(translator.outVarCheckRes(parseExpr(t.bytes, io, defEndian)), t.bytes)
-        val expr = translator.bytesToStr(translator.resToStr(r1), t.encoding)
+        val expr = translator.rawTerminatedBytesToStr(r1, t, id)
         handleAssignment(id, expr, rep, isRaw)
       case t: EnumType =>
         val r1 = translator.outVarCheckRes(parseExpr(t.basedOn, io, defEndian))
         val enumSpec = t.enumSpec.get
-        val expr = translator.trEnumById(enumSpec.name, translator.resToStr(r1))
+        val expr = translator.doEnumById(enumSpec.name, r1)
         handleAssignment(id, expr, rep, isRaw)
       case _: BitsType1 =>
         val expr = parseExpr(dataType, io, defEndian)
         val r1 = translator.outVarCheckRes(expr)
-        val r2 = ResultString(s"${translator.resToStr(r1)} != 0")
+        val r2 = s"${r1} != 0"
         handleAssignment(id, r2, rep, isRaw)
       case _ =>
         val expr = parseExpr(dataType, io, defEndian)
@@ -85,8 +111,8 @@ trait GoReads extends CommonReads with ObjectOrientedLanguage with GoSwitchOps {
     }
   }
 
-  def bytesPadTermExpr(id: ResultLocalVar, padRight: Option[Int], terminator: Option[Int], include: Boolean): String = {
-    val expr0 = translator.resToStr(id)
+  def bytesPadTermExpr(id: String, padRight: Option[Int], terminator: Option[Int], include: Boolean): String = {
+    val expr0 = id
     val expr1 = padRight match {
       case Some(padByte) => s"kaitai.BytesStripRight($expr0, $padByte)"
       case None => expr0
@@ -98,7 +124,7 @@ trait GoReads extends CommonReads with ObjectOrientedLanguage with GoSwitchOps {
     expr2
   }
 
-  def parseExprBytes(id: ResultLocalVar, dataType: BytesType): ResultLocalVar = {
+  def parseExprBytes(id: String, dataType: BytesType): String = {
     dataType match {
       case BytesEosType(terminator, include, padRight, _) =>
         translator.outTransform(id, bytesPadTermExpr(id, padRight, terminator, include))
@@ -136,21 +162,58 @@ trait GoReads extends CommonReads with ObjectOrientedLanguage with GoSwitchOps {
 
     val expr = translator.userType(dataType, newIO)
     handleAssignment(id, expr, rep, false)
+    translator.userTypeRead(expr)
   }
 
-  def handleAssignment(id: Identifier, expr: TranslatorResult, rep: RepeatSpec, isRaw: Boolean): Unit = {
-    rep match {
-      case RepeatEos => handleAssignmentRepeatEos(id, expr)
-      case RepeatExpr(_) => handleAssignmentRepeatExpr(id, expr)
-      case RepeatUntil(_) => handleAssignmentRepeatUntil(id, expr, isRaw)
-      case NoRepeat => handleAssignmentSimple(id, expr)
+  def createSubstreamBuffered(id: Identifier, byteType: BytesType, io: String, rep: RepeatSpec, defEndian: Option[FixedEndian]): String = {
+    val rawId = RawIdentifier(id)
+
+    attrParse2(rawId, byteType, io, rep, true, defEndian)
+
+    if (config.readWrite) {
+      if (writeNeedsOuterSize(byteType)) {
+        /** @note Must be kept in sync with [[attrBytesTypeParse]] */
+        val rawRawId = byteType.process match {
+          case None => rawId
+          case Some(_) => RawIdentifier(rawId)
+        }
+        val item = itemExpr(rawRawId, rep)
+        val itemSizeExprStr = expression(Ast.expr.Attribute(item, Ast.identifier("size")))
+
+        /** FIXME: cannot use [[handleAssignment]] because [[handleAssignmentRepeatUntil]]
+         * always tries to assign the value to the [[Identifier.ITERATOR]] variable */
+        if (rep == NoRepeat) {
+          handleAssignmentSimple(OuterSizeIdentifier(id), itemSizeExprStr)
+        } else {
+          handleAssignmentRepeatEos(OuterSizeIdentifier(id), itemSizeExprStr)
+        }
+      }
+      if (writeNeedsInnerSize(byteType)) {
+        val item = itemExpr(rawId, rep)
+        val itemSizeExprStr = expression(Ast.expr.Attribute(item, Ast.identifier("size")))
+
+        /** FIXME: cannot use [[handleAssignment]] because [[handleAssignmentRepeatUntil]]
+         * always tries to assign the value to the [[Identifier.ITERATOR]] variable */
+        if (rep == NoRepeat) {
+          handleAssignmentSimple(InnerSizeIdentifier(id), itemSizeExprStr)
+        } else {
+          handleAssignmentRepeatEos(InnerSizeIdentifier(id), itemSizeExprStr)
+        }
+      }
+    }
+
+    val extraType = rep match {
+      case NoRepeat => byteType
+      case _ => ArrayTypeInStream(byteType)
     }
-  }
 
-  def handleAssignmentRepeatEos(id: Identifier, expr: TranslatorResult): Unit
-  def handleAssignmentRepeatExpr(id: Identifier, expr: TranslatorResult): Unit
-  def handleAssignmentRepeatUntil(id: Identifier, expr: TranslatorResult, isRaw: Boolean): Unit
-  def handleAssignmentSimple(id: Identifier, expr: TranslatorResult): Unit
+    this match {
+      case thisStore: AllocateAndStoreIO =>
+        thisStore.allocateIO(rawId, rep)
+      case thisLocal: AllocateIOLocalVar =>
+        thisLocal.allocateIO(rawId, rep)
+    }
+  }
 
   def parseExpr(dataType: DataType, io: String, defEndian: Option[FixedEndian]): String
 }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/GoWrites.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/GoWrites.scala
new file mode 100644
index 000000000..0ed11ad7c
--- /dev/null
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/GoWrites.scala
@@ -0,0 +1,182 @@
+package io.kaitai.struct.languages.components
+
+import io.kaitai.struct.datatype.DataType._
+import io.kaitai.struct.datatype.{DataType, FixedEndian}
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format.{Identifier, InnerSizeIdentifier, OuterSizeIdentifier, ProcessExpr, RawIdentifier, RepeatSpec}
+
+trait GoWrites extends LanguageCompiler with CommonWrites with GoReads {
+  override def attrSwitchTypeWrite(id: Identifier, on: Ast.expr, cases: Map[Ast.expr, DataType], io: String, rep: RepeatSpec, defEndian: Option[FixedEndian], checksShouldDependOnIoOrig: Option[Boolean], assignType: DataType): Unit = {
+    val checksShouldDependOnIo =
+      if (userExprDependsOnIo(on)) {
+        None
+      } else {
+        checksShouldDependOnIoOrig
+      }
+
+    switchCases[DataType](id, on, cases,
+      (dataType) => {
+        attrWrite2(id, dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+      },
+      (dataType) => if (switchBytesOnlyAsRaw) {
+        dataType match {
+          case t: BytesType =>
+            attrWrite2(RawIdentifier(id), dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+          case _ =>
+            attrWrite2(id, dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+        }
+      } else {
+        attrWrite2(id, dataType, io, rep, false, defEndian, checksShouldDependOnIo, Some(assignType))
+      }
+    )
+  }
+
+  def attrUserTypeWrite(id: Identifier, t: UserType, io: String, rep: RepeatSpec, isRaw: Boolean, defEndian: Option[FixedEndian], checksShouldDependOnIo: Option[Boolean], exprTypeOpt: Option[DataType] = None): Unit = {
+    val exprType = exprTypeOpt.getOrElse(t)
+    val expr = itemExpr(id, rep)
+
+    {
+      val itemUserType =
+        if (exprTypeOpt.map(exprType => !exprType.isInstanceOf[UserType]).getOrElse(false))
+          Ast.expr.CastToType(expr, Ast.typeId(true, t.classSpec.get.name))
+        else
+          expr
+      // check non-`io` params
+      attrUserTypeCheck(id, itemUserType, t, checksShouldDependOnIo)
+      // set `io` params
+      (t.classSpec.get.params, t.args).zipped.foreach { (paramDef, argExpr) =>
+        val paramItemType = getArrayItemType(paramDef.dataType)
+        val paramBasedOnIo = (paramItemType == KaitaiStreamType || paramItemType == OwnedKaitaiStreamType)
+        if (paramBasedOnIo)
+          attrSetProperty(itemUserType, paramDef.id, expression(argExpr))
+      }
+    }
+
+    t match {
+      case _: UserTypeInstream =>
+        attrUserTypeInstreamWrite(io, expr, t, exprType)
+      case utb: UserTypeFromBytes =>
+        val rawId = RawIdentifier(id)
+        val byteType = utb.bytes
+
+        /** @note Must be kept in sync with [[ExtraAttrs.writeNeedsOuterSize]] */
+        val outerSize = byteType match {
+          case blt: BytesLimitType =>
+            translator.translate(blt.size)
+          case _: BytesEosType =>
+            exprIORemainingSize(io)
+          case _: BytesTerminatedType =>
+            translator.translate(itemExpr(OuterSizeIdentifier(id), rep))
+        }
+
+        /** @note Must be kept in sync with [[ExtraAttrs.writeNeedsInnerSize]] */
+        val innerSize = if (writeNeedsInnerSize(utb.bytes)) {
+          translator.translate(itemExpr(InnerSizeIdentifier(id), rep))
+        } else {
+          outerSize
+        }
+
+        this match {
+          //      case thisStore: AllocateAndStoreIO =>
+          //        val ourIO = thisStore.allocateIO(rawId, rep)
+          //        Utils.addUniqueAttr(extraAttrs, AttrSpec(List(), ourIO, KaitaiStreamType))
+          //        privateMemberName(ourIO)
+          case thisLocal: AllocateIOLocalVar =>
+            val ioFixed = thisLocal.allocateIOFixed(rawId, innerSize)
+            addChildIO(io, ioFixed)
+
+            pushPosForSubIOWriteBackHandler(io)
+            seekRelative(io, outerSize)
+            byteType match {
+              case t: BytesTerminatedType =>
+                if (!t.include && t.consume) {
+                  if (!t.eosError)
+                    condIfIsEofHeader(io, false)
+                  // terminator can only be 1 byte long at the moment
+                  seekRelative(io, expression(Ast.expr.IntNum(1)))
+                  if (!t.eosError)
+                    condIfIsEofFooter
+                }
+              case _ => // do nothing
+            }
+
+            byteType.process.foreach { (process) =>
+              attrUnprocessPrepareBeforeSubIOHandler(process, rawId)
+            }
+
+            {
+              val parentIO = subIOWriteBackHeader(ioFixed, byteType.process)
+              handleAssignment(rawId, exprStreamToByteArray(ioFixed), rep, true)
+              attrBytesTypeWrite(rawId, byteType, parentIO, rep, isRaw, None, exprTypeOpt)
+              subIOWriteBackFooter(ioFixed)
+            }
+
+            attrUserTypeInstreamWrite(ioFixed, expr, t, exprType)
+        }
+    }
+  }
+
+  override def attrBytesTypeWrite2(
+     id: Identifier,
+     io: String,
+     expr: Ast.expr,
+     t: BytesType,
+     checksShouldDependOnIo: Option[Boolean],
+     exprTypeOpt: Option[DataType]
+   ): Unit = {
+    attrBytesCheck(id, expr, t, checksShouldDependOnIo)
+    t match {
+      case bt: BytesEosType =>
+        attrBytesLimitWrite2(io, expr, bt, exprIORemainingSize(io), bt.padRight, bt.terminator, bt.include, exprTypeOpt)
+        attrIsEofCheck(id, true, io)
+      case bt: BytesLimitType =>
+        attrBytesLimitWrite2(io, expr, bt, expression(bt.size), bt.padRight, bt.terminator, bt.include, exprTypeOpt)
+      case t: BytesTerminatedType =>
+        attrPrimitiveWrite(io, expr, t, None, exprTypeOpt)
+        // Changed: delete terminated output
+    }
+  }
+
+  override def attrBytesLimitWrite2(
+    io: String,
+    expr: Ast.expr,
+    bt: BytesType,
+    sizeExpr: String,
+    padRight: Option[Int],
+    terminator: Option[Int],
+    include: Boolean,
+    exprTypeOpt: Option[DataType]
+  ): Unit = {
+    val (termArg, padRightArg) = (terminator, padRight, include) match {
+      case (None, None, false) =>
+        // no terminator, no padding => just a regular output
+        // validation should check that expression's length matches size
+        attrPrimitiveWrite(io, expr, bt, None, exprTypeOpt)
+        translator.handleUnfinsiedSizeExpr(sizeExpr)
+        return
+      case (_, None, true) =>
+        // terminator included, no padding => pad with zeroes
+        (0, 0)
+      case (_, Some(p), true) =>
+        // terminator included, padding specified
+        (p, p)
+      case (Some(t), None, false) =>
+        // only terminator given, don't care about what's gonna go after that
+        // we'll just pad with zeroes
+        (t, 0)
+      case (None, Some(p), false) =>
+        // only padding given, just add terminator equal to padding
+        (p, p)
+      case (Some(t), Some(p), false) =>
+        // both terminator and padding specified
+        (t, p)
+    }
+    attrBytesLimitWrite(io, expr, sizeExpr, termArg, padRightArg)
+  }
+
+  def attrUnprocessPrepareBeforeSubIOHandler(proc: ProcessExpr, varSrc: Identifier): Unit
+
+  def attrUserTypeInstreamWrite(io: String, expr: Ast.expr, t: DataType, exprType: DataType): Unit
+
+  def exprStreamToByteArray(ioFixed: String): String
+}
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/LanguageCompiler.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/LanguageCompiler.scala
index 76fc21a3c..9233e32d6 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/LanguageCompiler.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/LanguageCompiler.scala
@@ -87,6 +87,7 @@ abstract class LanguageCompiler(
   def classHeader(name: List[String]): Unit
   def classFooter(name: List[String]): Unit
   def classForwardDeclaration(name: List[String]): Unit = {}
+  def classExtendMarks(name: List[String]): Unit = {}
 
   def classConstructorHeader(name: List[String], parentType: DataType, rootClassName: List[String], isHybrid: Boolean, params: List[ParamDefSpec]): Unit
   def classConstructorFooter: Unit
@@ -116,6 +117,7 @@ abstract class LanguageCompiler(
 
   def attributeDeclaration(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit
   def attributeReader(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit
+  def attributeSetter(attrName: Identifier, attrType: DataType, isNullable: Boolean): Unit = ???
   def attributeDoc(id: Identifier, doc: DocSpec): Unit = {}
 
   def attrParse(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit
@@ -123,13 +125,29 @@ abstract class LanguageCompiler(
   def attrInit(attr: AttrLikeSpec): Unit = {}
   def attrDestructor(attr: AttrLikeSpec, id: Identifier): Unit = {}
 
-  // TODO: delete
-  def attrFixedContentsParse(attrName: Identifier, contents: Array[Byte]): Unit
+  def attrFetchInstances(attr: AttrLikeSpec, id: Identifier): Unit = {}
+  def fetchInstancesHeader(): Unit = {}
+  def fetchInstancesFooter(): Unit = {}
+  def attrInvokeFetchInstances(baseExpr: Ast.expr, exprType: DataType, dataType: DataType): Unit = ???
+  def attrInvokeInstance(instName: InstanceIdentifier): Unit = ???
+
+  def writeHeader(endian: Option[FixedEndian], isEmpty: Boolean): Unit = ???
+  def writeFooter(): Unit = ???
+  def writeInstanceHeader(instName: InstanceIdentifier): Unit = ???
+  def writeInstanceFooter(): Unit = ???
+  def attrWrite(attr: AttrLikeSpec, id: Identifier, defEndian: Option[Endianness]): Unit = ???
+  def runWriteCalc(): Unit = ???
+
+  def checkHeader(): Unit = ???
+  def checkFooter(): Unit = ???
+  def checkInstanceHeader(instName: InstanceIdentifier): Unit = ???
+  def checkInstanceFooter(): Unit = ???
+  def attrCheck(attr: AttrLikeSpec, id: Identifier): Unit = ???
 
   def condIfSetNull(instName: Identifier): Unit = {}
   def condIfSetNonNull(instName: Identifier): Unit = {}
   def condIfHeader(expr: Ast.expr): Unit
-  def condIfFooter(expr: Ast.expr): Unit
+  def condIfFooter: Unit
 
   def condRepeatInitAttr(id: Identifier, dataType: DataType): Unit
 
@@ -142,24 +160,45 @@ abstract class LanguageCompiler(
   def condRepeatUntilHeader(id: Identifier, io: String, dataType: DataType, untilExpr: Ast.expr): Unit
   def condRepeatUntilFooter(id: Identifier, io: String, dataType: DataType, untilExpr: Ast.expr): Unit
 
+  def condRepeatCommonHeader(id: Identifier, io: String, dataType: DataType): Unit = {}
+  def condRepeatCommonFooter: Unit = {}
+
   def attrProcess(proc: ProcessExpr, varSrc: Identifier, varDest: Identifier, rep: RepeatSpec): Unit
 
   def normalIO: String
   def useIO(ioEx: Ast.expr): String
   def pushPos(io: String): Unit
+  def pushPosForSubIOWriteBackHandler(io: String): Unit = ???
   def seek(io: String, pos: Ast.expr): Unit
+  def seekRelative(io: String, relPos: String): Unit = ???
   def popPos(io: String): Unit
   def alignToByte(io: String): Unit
 
+  def exprIORemainingSize(io: String): String = ???
+
+  def subIOWriteBackHeader(subIO: String, process: Option[ProcessExpr]): String = ???
+  def subIOWriteBackFooter(subIO: String): Unit = ???
+  def subIOWriteBackSetter(subIO: String): Unit = ???
+
+  def addChildIO(io: String, childIO: String): Unit = ???
+
   def instanceDeclHeader(className: List[String]): Unit = {}
   def instanceClear(instName: InstanceIdentifier): Unit = {}
   def instanceSetCalculated(instName: InstanceIdentifier): Unit = {}
   def instanceDeclaration(attrName: InstanceIdentifier, attrType: DataType, isNullable: Boolean): Unit = attributeDeclaration(attrName, attrType, isNullable)
+  def instanceWriteFlagDeclaration(attrName: InstanceIdentifier): Unit = ???
+  def instanceWriteFlagInit(attrName: InstanceIdentifier): Unit = {}
+  def instanceSetWriteFlag(instName: InstanceIdentifier): Unit = ???
+  def instanceClearWriteFlag(instName: InstanceIdentifier): Unit = ???
+  def instanceToWriteSetter(instName: InstanceIdentifier): Unit = ???
+  def instanceSetter(className: List[String], instName: InstanceIdentifier, dataType: DataType): Unit = {}
   def instanceHeader(className: List[String], instName: InstanceIdentifier, dataType: DataType, isNullable: Boolean): Unit
   def instanceFooter: Unit
   def instanceCheckCacheAndReturn(instName: InstanceIdentifier, dataType: DataType): Unit
   def instanceReturn(instName: InstanceIdentifier, attrType: DataType): Unit
   def instanceCalculate(instName: Identifier, dataType: DataType, value: Ast.expr)
+  def instanceInvalidate(instName: InstanceIdentifier): Unit = ???
+  def instanceCheckWriteFlagAndWrite(instName: InstanceIdentifier): Unit = ???
 
   def enumDeclaration(curClass: List[String], enumName: String, enumColl: Seq[(Long, EnumValueSpec)]): Unit
 
@@ -192,7 +231,7 @@ abstract class LanguageCompiler(
 
   def attrParseIfFooter(ifExpr: Option[Ast.expr]): Unit = {
     ifExpr match {
-      case Some(e) => condIfFooter(e)
+      case Some(e) => condIfFooter
       case None => // ignore
     }
   }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/UniversalFooter.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/UniversalFooter.scala
index bbfd392b8..2beb55b67 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/UniversalFooter.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/UniversalFooter.scala
@@ -1,12 +1,13 @@
 package io.kaitai.struct.languages.components
 
 import io.kaitai.struct.exprlang.Ast.expr
+import io.kaitai.struct.format.ClassSpec
 
 /**
   * All footers in the language look the same and can be written by the same
   * simple argument-less method.
   */
-trait UniversalFooter {
+trait UniversalFooter extends LanguageCompiler {
   /**
     * Single method that outputs all kind of footers in the language.
     */
@@ -14,8 +15,14 @@ trait UniversalFooter {
 
   def classFooter(name: String): Unit = universalFooter
   def classConstructorFooter: Unit = universalFooter
+  override def readFooter: Unit = universalFooter
+  override def writeFooter: Unit = universalFooter
+  override def writeInstanceFooter: Unit = universalFooter
+  override def checkFooter: Unit = universalFooter
+  override def checkInstanceFooter: Unit = universalFooter
   def condRepeatExprFooter = universalFooter
   def condRepeatEosFooter: Unit = universalFooter
-  def condIfFooter(expr: expr): Unit = universalFooter
+  override def condRepeatCommonFooter: Unit = universalFooter
+  def condIfFooter: Unit = universalFooter
   def instanceFooter: Unit = universalFooter
 }
diff --git a/shared/src/main/scala/io/kaitai/struct/languages/components/ValidateOps.scala b/shared/src/main/scala/io/kaitai/struct/languages/components/ValidateOps.scala
index 39290579c..1116292a6 100644
--- a/shared/src/main/scala/io/kaitai/struct/languages/components/ValidateOps.scala
+++ b/shared/src/main/scala/io/kaitai/struct/languages/components/ValidateOps.scala
@@ -13,17 +13,17 @@ trait ValidateOps extends ExceptionNames {
   val translator: AbstractTranslator
   val typeProvider: ClassTypeProvider
 
-  def attrValidate(attrId: Identifier, attr: AttrLikeSpec, valid: ValidationSpec): Unit = {
+  def attrValidate(attrId: Identifier, attr: AttrLikeSpec, valid: ValidationSpec, useIo: Boolean): Unit = {
     valid match {
       case ValidationEq(expected) =>
-        attrValidateExprCompare(attrId, attr, Ast.cmpop.Eq, expected, ValidationNotEqualError(attr.dataTypeComposite))
+        attrValidateExprCompare(attrId, attr, Ast.cmpop.Eq, expected, ValidationNotEqualError(attr.dataTypeComposite), useIo)
       case ValidationMin(min) =>
-        attrValidateExprCompare(attrId, attr, Ast.cmpop.GtE, min, ValidationLessThanError(attr.dataTypeComposite))
+        attrValidateExprCompare(attrId, attr, Ast.cmpop.GtE, min, ValidationLessThanError(attr.dataTypeComposite), useIo)
       case ValidationMax(max) =>
-        attrValidateExprCompare(attrId, attr, Ast.cmpop.LtE, max, ValidationGreaterThanError(attr.dataTypeComposite))
+        attrValidateExprCompare(attrId, attr, Ast.cmpop.LtE, max, ValidationGreaterThanError(attr.dataTypeComposite), useIo)
       case ValidationRange(min, max) =>
-        attrValidateExprCompare(attrId, attr, Ast.cmpop.GtE, min, ValidationLessThanError(attr.dataTypeComposite))
-        attrValidateExprCompare(attrId, attr, Ast.cmpop.LtE, max, ValidationGreaterThanError(attr.dataTypeComposite))
+        attrValidateExprCompare(attrId, attr, Ast.cmpop.GtE, min, ValidationLessThanError(attr.dataTypeComposite), useIo)
+        attrValidateExprCompare(attrId, attr, Ast.cmpop.LtE, max, ValidationGreaterThanError(attr.dataTypeComposite), useIo)
       case ValidationAnyOf(values) =>
         val bigOrExpr = Ast.expr.BoolOp(
           Ast.boolop.Or,
@@ -37,59 +37,55 @@ trait ValidateOps extends ExceptionNames {
         )
 
         attrValidateExpr(
-          attrId,
-          attr.dataTypeComposite,
+          attr,
           checkExpr = bigOrExpr,
           err = ValidationNotAnyOfError(attr.dataTypeComposite),
-          errArgs = List(
-            Ast.expr.InternalName(attrId),
-            Ast.expr.InternalName(IoIdentifier),
-            Ast.expr.Str(attr.path.mkString("/", "/", ""))
-          )
+          useIo
         )
       case ValidationExpr(expr) =>
         blockScopeHeader
         typeProvider._currentIteratorType = Some(attr.dataTypeComposite)
+        // this assignment have no effect and will make some error in go or other language
+        // which has unused variable check
+        /*
         handleAssignmentTempVar(
           attr.dataTypeComposite,
           translator.translate(Ast.expr.Name(Ast.identifier(Identifier.ITERATOR))),
           translator.translate(Ast.expr.InternalName(attrId))
         )
+        */
         attrValidateExpr(
-          attrId,
-          attr.dataTypeComposite,
+          attr,
           expr,
           ValidationExprError(attr.dataTypeComposite),
-          List(
-            Ast.expr.InternalName(attrId),
-            Ast.expr.InternalName(IoIdentifier),
-            Ast.expr.Str(attr.path.mkString("/", "/", ""))
-          )
+          useIo
         )
         blockScopeFooter
     }
   }
 
-  def attrValidateExprCompare(attrId: Identifier, attr: AttrLikeSpec, op: Ast.cmpop, expected: Ast.expr, err: KSError): Unit = {
+  def attrValidateExprCompare(
+    attrId: Identifier,
+    attr: AttrLikeSpec,
+    op: Ast.cmpop,
+    expected: Ast.expr,
+    err: KSError,
+    useIo: Boolean
+  ): Unit = {
     attrValidateExpr(
-      attrId,
-      attr.dataTypeComposite,
+      attr,
       checkExpr = Ast.expr.Compare(
         Ast.expr.InternalName(attrId),
         op,
         expected
       ),
       err = err,
-      errArgs = List(
-        expected,
-        Ast.expr.InternalName(attrId),
-        Ast.expr.InternalName(IoIdentifier),
-        Ast.expr.Str(attr.path.mkString("/", "/", ""))
-      )
+      useIo = useIo,
+      expected = Some(expected)
     )
   }
 
-  def attrValidateExpr(attrId: Identifier, attrType: DataType, checkExpr: Ast.expr, err: KSError, errArgs: List[Ast.expr]): Unit = {}
+  def attrValidateExpr(attr: AttrLikeSpec, checkExpr: Ast.expr, err: KSError, useIo: Boolean, expected: Option[Ast.expr] = None): Unit = {}
   def handleAssignmentTempVar(dataType: DataType, id: String, expr: String): Unit
   def blockScopeHeader: Unit
   def blockScopeFooter: Unit
diff --git a/shared/src/main/scala/io/kaitai/struct/precompile/ParentTypes.scala b/shared/src/main/scala/io/kaitai/struct/precompile/ParentTypes.scala
index 288267786..30873e74c 100644
--- a/shared/src/main/scala/io/kaitai/struct/precompile/ParentTypes.scala
+++ b/shared/src/main/scala/io/kaitai/struct/precompile/ParentTypes.scala
@@ -89,9 +89,9 @@ class ParentTypes(classSpecs: ClassSpecs) {
         } else {
           // conflicting types, would be bad for statically typed languages
           // throw new RuntimeException(s"type '${attr.dataType}' has more than 1 conflicting parent types: ${otherName} and ${curClassName}")
-          child.parentClass = GenericStructClassSpec
+          child.parentClass = MultiParentClassSpec
         }
-      case GenericStructClassSpec =>
+      case _ =>
         // already most generic case, do nothing
     }
   }
diff --git a/shared/src/main/scala/io/kaitai/struct/precompile/ResolveTypes.scala b/shared/src/main/scala/io/kaitai/struct/precompile/ResolveTypes.scala
index 01b7f494c..d9f88b4d4 100644
--- a/shared/src/main/scala/io/kaitai/struct/precompile/ResolveTypes.scala
+++ b/shared/src/main/scala/io/kaitai/struct/precompile/ResolveTypes.scala
@@ -49,7 +49,7 @@ class ResolveTypes(specs: ClassSpecs, opaqueTypes: Boolean) extends PrecompileSt
         ut.classSpec = resClassSpec
         problems
       case et: EnumType =>
-        et.enumSpec = resolveEnumSpec(curClass, et.name)
+        et.enumSpec = resolveEnumSpec(curClass, et.name, et.basedOn)
         if (et.enumSpec.isEmpty) {
           Some(EnumNotFoundErr(et.name, curClass, path))
         } else {
@@ -134,10 +134,10 @@ class ResolveTypes(specs: ClassSpecs, opaqueTypes: Boolean) extends PrecompileSt
     }
   }
 
-  def resolveEnumSpec(curClass: ClassSpec, typeName: List[String]): Option[EnumSpec] = {
+  def resolveEnumSpec(curClass: ClassSpec, typeName: List[String], basedOnType: DataType = null): Option[EnumSpec] = {
     Log.enumResolve.info(() => s"resolveEnumSpec: at ${curClass.name} doing ${typeName.mkString("|")}")
 
-    val res = realResolveEnumSpec(curClass, typeName)
+    val res = realResolveEnumSpec(curClass, typeName, basedOnType)
     res match {
       case None => {
         Log.enumResolve.info(() => s"    => ???")
@@ -150,7 +150,7 @@ class ResolveTypes(specs: ClassSpecs, opaqueTypes: Boolean) extends PrecompileSt
     }
   }
 
-  private def realResolveEnumSpec(curClass: ClassSpec, typeName: List[String]): Option[EnumSpec] = {
+  private def realResolveEnumSpec(curClass: ClassSpec, typeName: List[String], basedOnType: DataType = null): Option[EnumSpec] = {
     // First, try to do it in current class
 
     // If we're seeking composite name, we only have to resolve the very first
@@ -158,10 +158,17 @@ class ResolveTypes(specs: ClassSpecs, opaqueTypes: Boolean) extends PrecompileSt
     val firstName :: restNames = typeName
 
     val resolvedHere = if (restNames.isEmpty) {
-      curClass.enums.get(firstName)
+      val rawEnum = curClass.enums.get(firstName)
+      if (rawEnum.isEmpty) {
+        None
+      } else {
+        val gettedEnum = rawEnum.get
+        gettedEnum.enumType = basedOnType
+        Some(gettedEnum)
+      }
     } else {
       curClass.types.get(firstName).flatMap((nestedClass) =>
-        resolveEnumSpec(nestedClass, restNames)
+        resolveEnumSpec(nestedClass, restNames, basedOnType)
       )
     }
 
@@ -171,11 +178,11 @@ class ResolveTypes(specs: ClassSpecs, opaqueTypes: Boolean) extends PrecompileSt
         // No luck resolving here, let's try upper levels, if they exist
         curClass.upClass match {
           case Some(upClass) =>
-            resolveEnumSpec(upClass, typeName)
+            resolveEnumSpec(upClass, typeName, basedOnType)
           case None =>
             // Check this class if it's top-level class
             if (curClass.name.head == firstName) {
-              resolveEnumSpec(curClass, restNames)
+              resolveEnumSpec(curClass, restNames, basedOnType)
             } else {
               // Check if top-level specs has this name
               // If there's None => no luck at all
@@ -186,7 +193,7 @@ class ResolveTypes(specs: ClassSpecs, opaqueTypes: Boolean) extends PrecompileSt
                   // resolved everything, but this points to a type name, not enum name
                   None
                 } else {
-                  resolveEnumSpec(classSpec, restNames)
+                  resolveEnumSpec(classSpec, restNames, basedOnType)
                 }
               }
             }
diff --git a/shared/src/main/scala/io/kaitai/struct/translators/BaseTranslator.scala b/shared/src/main/scala/io/kaitai/struct/translators/BaseTranslator.scala
index 93017cecf..fb11ef5ba 100644
--- a/shared/src/main/scala/io/kaitai/struct/translators/BaseTranslator.scala
+++ b/shared/src/main/scala/io/kaitai/struct/translators/BaseTranslator.scala
@@ -82,7 +82,7 @@ abstract class BaseTranslator(val provider: TypeProvider)
         }
       case Ast.expr.Compare(left: Ast.expr, op: Ast.cmpop, right: Ast.expr) =>
         (detectType(left), detectType(right)) match {
-          case (_: NumericType, _: NumericType) =>
+          case (l: NumericType, r: NumericType) =>
             doNumericCompareOp(left, op, right)
           case (_: BooleanType, _: BooleanType) =>
             op match {
diff --git a/shared/src/main/scala/io/kaitai/struct/translators/CommonMethods.scala b/shared/src/main/scala/io/kaitai/struct/translators/CommonMethods.scala
index 6312a67d9..9e3af9fed 100644
--- a/shared/src/main/scala/io/kaitai/struct/translators/CommonMethods.scala
+++ b/shared/src/main/scala/io/kaitai/struct/translators/CommonMethods.scala
@@ -97,6 +97,7 @@ abstract trait CommonMethods[T] extends TypeDetector {
           // TODO: check argument quantity
           case (_: StrType, "substring") => strSubstring(obj, args(0), args(1))
           case (_: StrType, "to_i") => strToInt(obj, args(0))
+          case (_: StrType, "to_b") => strToBytes(obj, args(0))
           case (_: BytesType, "to_s") =>
             args match {
               case Seq(Ast.expr.Str(encoding)) =>
@@ -106,6 +107,7 @@ abstract trait CommonMethods[T] extends TypeDetector {
               case _ =>
                 throw new TypeMismatchError(s"to_s: expected 1 argument, got ${args.length}")
             }
+          case (_: BytesType, "index_of") => bytesIndexOf(obj, args(0))
           case _ => throw new TypeMismatchError(s"don't know how to call method '$methodName' of object type '$objType'")
         }
     }
@@ -125,8 +127,10 @@ abstract trait CommonMethods[T] extends TypeDetector {
   def strReverse(s: Ast.expr): T
   def strToInt(s: Ast.expr, base: Ast.expr): T
   def strSubstring(s: Ast.expr, from: Ast.expr, to: Ast.expr): T
+  def strToBytes(s: Ast.expr, encoding: Ast.expr): T = ???
 
   def bytesToStr(value: Ast.expr, encoding: String): T
+  def bytesIndexOf(value: Ast.expr, expr: Ast.expr): T = ???
 
   def intToStr(value: Ast.expr, num: Ast.expr): T
 
diff --git a/shared/src/main/scala/io/kaitai/struct/translators/GoTranslator.scala b/shared/src/main/scala/io/kaitai/struct/translators/GoTranslator.scala
index 116e02462..a3a1589b4 100644
--- a/shared/src/main/scala/io/kaitai/struct/translators/GoTranslator.scala
+++ b/shared/src/main/scala/io/kaitai/struct/translators/GoTranslator.scala
@@ -3,174 +3,147 @@ package io.kaitai.struct.translators
 import io.kaitai.struct.datatype.DataType
 import io.kaitai.struct.datatype.DataType._
 import io.kaitai.struct.exprlang.Ast
-import io.kaitai.struct.format.{ClassSpec, Identifier}
+import io.kaitai.struct.format.{ClassSpec, Identifier, InstanceIdentifier, MultiParentClassSpec, NamedIdentifier, SpecialIdentifier}
 import io.kaitai.struct.languages.GoCompiler
+import io.kaitai.struct.{ClassTypeProvider, ImportList, RuntimeConfig, StringLanguageOutputWriter, Utils}
 import io.kaitai.struct.precompile.TypeMismatchError
-import io.kaitai.struct.{ImportList, StringLanguageOutputWriter, Utils}
-import io.kaitai.struct.format.SpecialIdentifier
-import io.kaitai.struct.format.NamedIdentifier
-import io.kaitai.struct.format.InstanceIdentifier
-
-sealed trait TranslatorResult
-case class ResultString(s: String) extends TranslatorResult
-case class ResultLocalVar(n: Int) extends TranslatorResult
-
-class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, importList: ImportList)
-  extends TypeDetector(provider)
-  with AbstractTranslator
-  with CommonLiterals
-  with CommonOps
-  with CommonArraysAndCast[TranslatorResult]
-  with CommonMethods[TranslatorResult]
-  with ByteArraysAsTrueArrays[TranslatorResult] {
 
+class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, importList: ImportList, config: RuntimeConfig) extends BaseTranslator(provider) {
   import io.kaitai.struct.languages.GoCompiler._
 
   var returnRes: Option[String] = None
 
-  override def translate(v: Ast.expr): String = resToStr(translateExpr(v))
-
-  def resToStr(r: TranslatorResult): String = r match {
-    case ResultString(s) => s
-    case ResultLocalVar(n) => localVarName(n)
-  }
-
-  def translateExpr(v: Ast.expr): TranslatorResult = {
-    v match {
-      case Ast.expr.IntNum(n) =>
-        trIntLiteral(n)
-      case Ast.expr.FloatNum(n) =>
-        trFloatLiteral(n)
-      case Ast.expr.Str(s) =>
-        trStringLiteral(s)
-      case Ast.expr.Bool(n) =>
-        trBoolLiteral(n)
-      case Ast.expr.EnumById(enumType, id, inType) =>
-        val enumSpec = provider.resolveEnum(inType, enumType.name)
-        trEnumById(enumSpec.name, translate(id))
-      case Ast.expr.EnumByLabel(enumType, label, inType) =>
-        val enumSpec = provider.resolveEnum(inType, enumType.name)
-        trEnumByLabel(enumSpec.name, label.name)
-      case Ast.expr.Name(name: Ast.identifier) =>
-        if (name.name == Identifier.SIZEOF) {
-          byteSizeOfClassSpec(provider.nowClass)
-        } else {
-          trLocalName(name.name)
-        }
-      case Ast.expr.InternalName(id: Identifier) =>
-        trInternalName(id)
-      case Ast.expr.UnaryOp(op: Ast.unaryop, inner: Ast.expr) =>
-        val opStr = unaryOp(op)
-        ResultString((op, inner) match {
-          /** [[doIntLiteral]] has to know when a negative number is being translated - if it
-           * doesn't, the result is things like `-uint32(2147483648)` that will not compile in Go
-           * (the error is "constant -2147483648 overflows uint32") */
-          case (Ast.unaryop.Minus, Ast.expr.IntNum(n)) => translate(Ast.expr.IntNum(-n))
-          case (_, Ast.expr.IntNum(_) | Ast.expr.FloatNum(_)) =>
-            s"$opStr${translate(inner)}"
-          case _ =>
-            s"$opStr(${translate(inner)})"
-        })
-      case Ast.expr.Compare(left, op, right) =>
-        (detectType(left), detectType(right)) match {
-          case (_: NumericType, _: NumericType) =>
-            trNumericCompareOp(left, op, right)
-          case (_: StrType, _: StrType) =>
-            trStrCompareOp(left, op, right)
-          case (_: BytesType, _: BytesType) =>
-            trBytesCompareOp(left, op, right)
-          case (_: BooleanType, _: BooleanType) =>
-            trNumericCompareOp(left, op, right)
-          case (_: EnumType, _: EnumType) =>
-            trNumericCompareOp(left, op, right)
-          case (ltype, rtype) =>
-            throw new TypeMismatchError(s"can't do $ltype $op $rtype")
-        }
-      case Ast.expr.BinOp(left: Ast.expr, op: Ast.operator, right: Ast.expr) =>
-        (detectType(left), detectType(right), op) match {
-          case (_: NumericType, _: NumericType, _) =>
-            trNumericBinOp(left, op, right)
-          case (_: StrType, _: StrType, Ast.operator.Add) =>
-            trStrConcat(left, right)
-          case (ltype, rtype, _) =>
-            throw new TypeMismatchError(s"can't do $ltype $op $rtype")
-        }
-      case Ast.expr.BoolOp(op, values) =>
-        trBooleanOp(op, values)
-      case Ast.expr.IfExp(condition, ifTrue, ifFalse) =>
-        trIfExp(condition, ifTrue, ifFalse)
-      case Ast.expr.Subscript(container, idx) =>
-        arraySubscript(container, idx)
-      case call: Ast.expr.Attribute =>
-        translateAttribute(call)
-      case call: Ast.expr.Call =>
-        translateCall(call)
-      case Ast.expr.List(elts) =>
-        doGuessArrayLiteral(elts)
-      case ctt: Ast.expr.CastToType =>
-        doCastOrArray(ctt)
-      case Ast.expr.ByteSizeOfType(typeName) =>
-        doByteSizeOfType(typeName)
-      case Ast.expr.BitSizeOfType(typeName) =>
-        doBitSizeOfType(typeName)
+  override def doNumericCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String = {
+    val rawLeft = translate(left)
+    val castedType = doCast(right, detectType(left))
+    // TODO: very ugly
+    var oops = op
+    if (rawLeft.contains("newBytes") || (rawLeft.contains("wirte") && rawLeft.contains("Byte")) && op == Ast.cmpop.NotEq) {
+        oops = Ast.cmpop.Eq
+    }
+    // TODO: resolve so many brackets
+    detectType(right) match {
+      case _: IntMultiType | _: FloatMultiType => s"$rawLeft ${cmpOp(oops)} $castedType"
+      case CalcIntType => s"$rawLeft ${cmpOp(oops)} ${if (rawLeft.startsWith("len(") && castedType.startsWith("(")) s"int$castedType" else if (castedType.startsWith("tmp")) s"int($castedType)" else castedType }"
+      case _ => s"(($rawLeft) ${cmpOp(oops)} ${if (rawLeft.startsWith("len(")) "int(" + s"$castedType)" else s"($castedType)"})"
     }
   }
 
-  def trIntLiteral(n: BigInt): TranslatorResult = ResultString(doIntLiteral(n))
-  def trFloatLiteral(n: BigDecimal): TranslatorResult = ResultString(doFloatLiteral(n))
-  def trStringLiteral(s: String): TranslatorResult = ResultString(doStringLiteral(s))
-  def trBoolLiteral(n: Boolean): TranslatorResult = ResultString(doBoolLiteral(n))
+  override def doStrCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String = {
+    val fn = (side: Ast.expr, s: Boolean, translated: String) => {
+      detectType(side) match {
+        case bytesType: StrFromBytesType if bytesType.bytes.isInstanceOf[BytesTerminatedType] =>
+          val btt = bytesType.bytes.asInstanceOf[BytesTerminatedType]
+          if (btt != null) {
+            val r = if (s) {
+              s"$translated.String()"
+            } else {
+              s"$translated.Write()"
+            }
+            r
+          } else {
+            s"$translated"
+          }
+        case _ =>
+          s"$translated"
+      }
+    }
+    s"${fn(left, true, translate(left))} ${cmpOp(op)} ${fn(right, false, translate(right))}"
+  }
 
-  def doByteSizeOfType(typeName: Ast.typeId): TranslatorResult = trIntLiteral(
+  override def doByteSizeOfType(typeName: Ast.typeId): String = doIntLiteral(
     CommonSizeOf.bitToByteSize(
       CommonSizeOf.getBitsSizeOfType(
         typeName.nameAsStr, detectCastType(typeName)
       )
     )
   )
-  def doBitSizeOfType(typeName: Ast.typeId): TranslatorResult = trIntLiteral(
+  override def doBitSizeOfType(typeName: Ast.typeId): String = doIntLiteral(
     CommonSizeOf.getBitsSizeOfType(
       typeName.nameAsStr, detectCastType(typeName)
     )
   )
-  def byteSizeOfClassSpec(cs: ClassSpec): TranslatorResult =
-    trIntLiteral(CommonSizeOf.getByteSizeOfClassSpec(cs))
+  override def byteSizeOfClassSpec(cs: ClassSpec): String =
+    doIntLiteral(CommonSizeOf.getByteSizeOfClassSpec(cs))
+
+  override def bytesIndexOf(b: Ast.expr, byte: Ast.expr): String = {
+    importList.add("bytes")
 
-  def trBooleanOp(op: Ast.boolop, values: Seq[Ast.expr]) =
-    ResultString(doBooleanOp(op, values))
+    val t = detectType(b)
+    s"bytes.IndexByte(${terminatedTypeConvert(b, t)}, ${translate(byte)})"
+  }
 
-  def trNumericBinOp(left: Ast.expr, op: Ast.operator, right: Ast.expr): TranslatorResult = {
+  override def numericBinOp(left: Ast.expr, op: Ast.operator, right: Ast.expr): String = {
+    val compiler = new GoCompiler(provider.asInstanceOf[ClassTypeProvider], config)
     (detectType(left), detectType(right), op) match {
       case (t1: IntType, t2: IntType, Ast.operator.Mod) =>
-        val v1 = allocateLocalVar()
-        out.puts(s"${localVarName(v1)} := ${translate(left)} % ${translate(right)}")
-        out.puts(s"if ${localVarName(v1)} < 0 {")
-        out.inc
-        out.puts(s"${localVarName(v1)} += ${translate(right)}")
-        out.dec
-        out.puts("}")
-        ResultLocalVar(v1)
+        s"(${translate(left)} % ${translate(right)} + ${translate(right)}) % ${translate(right)}"
+      // TODO: for go, this is special
+      case (t1: IntType, t2: IntType, _) => {
+        val t1T = compiler.kaitaiType2NativeType(t1)
+        val t1Size = t1 match {
+          case CalcIntType => 32
+          case it :IntMultiType => it.width.width * 8
+          case _: Int1Type => 8
+          case _ => 32
+        }
+        val t2T = compiler.kaitaiType2NativeType(t2)
+        val t2Size = t2 match {
+          case CalcIntType => 32
+          case it: IntMultiType => it.width.width * 8
+          case _: Int1Type => 8
+          case _ => 32
+        }
+
+        val binsOp = binOp(op)
+        val res = if (t2T != t1T) {
+          if (binsOp == "<<" || binsOp == ">>") {
+            s"int(${translate(left)}) $binsOp int(${translate(right)})"
+          } else {
+            if (t1Size > t2Size) {
+              s"(${t1T}(${translate(left)}) $binsOp ${t1T}(${translate(right)}))"
+            } else {
+              s"(${t2T}(${translate(left)}) $binsOp ${t2T}(${translate(right)}))"
+            }
+          }
+        } else {
+          val tl = translate(left)
+          val tr = translate(right)
+          val r = if (!tl.contains(s"($t1T(") || !tr.contains(s"($t2T(")) {
+            s"($t1T($tl) $binsOp $t2T($tr))"
+          } else {
+            s"($tl $binsOp $tr})"
+          }
+          r
+        }
+        res
+      }
       case _ =>
-        ResultString(numericBinOp(left, op, right))
+        s"(${translate(left)} ${binOp(op)} ${translate(right)})"
     }
   }
 
-  def trStrConcat(left: Ast.expr, right: Ast.expr): TranslatorResult =
-    ResultString(translate(left) + " + " + translate(right))
+  override def strConcat(left: Ast.expr, right: Ast.expr): String = {
+    var translatedLeft = translate(left)
+    var translatedRight = translate(right)
 
-  def trNumericCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): TranslatorResult =
-    ResultString(doNumericCompareOp(left, op, right))
+    if (detectType(left).isInstanceOf[StrFromBytesType] && detectType(left).asInstanceOf[StrFromBytesType].bytes.isInstanceOf[BytesTerminatedType]) {
+      translatedLeft = s"$translatedLeft.String()"
+    }
+    if (detectType(right).isInstanceOf[StrFromBytesType] && detectType(right).asInstanceOf[StrFromBytesType].bytes.isInstanceOf[BytesTerminatedType]) {
+      translatedRight = s"$translatedRight.String()"
+    }
 
-  def trStrCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): TranslatorResult =
-    ResultString(doStrCompareOp(left, op, right))
+    translatedLeft + " + " + translatedRight
+  }
 
-  def trBytesCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): TranslatorResult = {
+  override def doBytesCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String = {
     importList.add("bytes")
     op match {
       case Ast.cmpop.Eq =>
-        ResultString(s"bytes.Equal(${translate(left)}, ${translate(right)})")
+        s"bytes.Equal(${translate(left)}, ${translate(right)})"
       case _ =>
-        ResultString(s"(bytes.Compare(${translate(left)}, ${translate(right)}) ${cmpOp(op)} 0)")
+        s"(bytes.Compare(${translate(left)}, ${translate(right)}) ${cmpOp(op)} 0)"
     }
   }
 
@@ -198,34 +171,51 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
     case Ast.unaryop.Not => "!"
   }
 
-  def trLocalName(s: String): TranslatorResult = {
+  override def doName(s: String): String = {
+    s match {
+      case Identifier.ROOT |
+           Identifier.PARENT |
+           Identifier.IO |
+           Identifier.ITERATOR | Identifier.ITERATOR2 =>
+        specialName(s)
+      case _ =>
+        Utils.upperCamelCase(s)
+    }
+  }
+
+  override def doLocalName(s: String): String = {
     s match {
       case Identifier.ROOT |
            Identifier.PARENT |
            Identifier.IO =>
-        ResultString(s"this.${specialName(s)}")
+        s"this.${specialName(s)}"
 
       // These can be local only
       case Identifier.ITERATOR |
            Identifier.ITERATOR2 =>
-        ResultString(specialName(s))
-      case Identifier.INDEX => ResultString("i")
+        specialName(s)
+      case Identifier.INDEX => "i"
 
       case _ =>
         if (provider.isLazy(s)) {
-          outVarCheckRes(s"this.${Utils.upperCamelCase(s)}()")
+          if (s == "fetchInstances") {
+            outVarCheckRes(s"this.${doName(s)}()")
+          } else {
+            outVarCheckRes(s"this.Get${Utils.lowerCamelCase(s)}()")
+          }
+
         } else {
-          ResultString(s"this.${Utils.upperCamelCase(s)}")
+          s"this.${doName(s)}"
         }
     }
   }
 
-  def trInternalName(id: Identifier): TranslatorResult =
+  override def doInternalName(id: Identifier): String  =
     id match {
-      case SpecialIdentifier(name) => trLocalName(name)
-      case NamedIdentifier(name) => trLocalName(name)
-      case InstanceIdentifier(name) => trLocalName(name)
-      case _ => ResultString(s"this.${GoCompiler.publicMemberName(id)}")
+      case SpecialIdentifier(name) => doLocalName(name)
+      case NamedIdentifier(name) => doLocalName(name)
+      case InstanceIdentifier(name) => doLocalName(name)
+      case _ => s"this.${GoCompiler.publicMemberName(id)}"
     }
 
   def specialName(id: String): String = id match {
@@ -237,51 +227,77 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
       "_buf"
   }
 
-  def arraySubscript(container: Ast.expr, idx: Ast.expr) =
-    ResultString(s"${translate(container)}[${translate(idx)}]")
+  override def arraySubscript(container: Ast.expr, idx: Ast.expr) = s"${translate(container)}[${translate(idx)}]"
 
-  def trIfExp(condition: Ast.expr, ifTrue: Ast.expr, ifFalse: Ast.expr): ResultLocalVar = {
+  override def doIfExp(condition: Ast.expr, ifTrue: Ast.expr, ifFalse: Ast.expr): String = {
+    val compiler = new GoCompiler(provider.asInstanceOf[ClassTypeProvider], config)
     val v1 = allocateLocalVar()
     val typ = detectType(ifTrue)
-    out.puts(s"var ${localVarName(v1)} ${GoCompiler.kaitaiType2NativeType(typ)};")
-    out.puts(s"if (${translate(condition)}) {")
-    out.inc
-    out.puts(s"${localVarName(v1)} = ${translate(ifTrue)}")
-    out.dec
-    out.puts("} else {")
-    out.inc
-    out.puts(s"${localVarName(v1)} = ${translate(ifFalse)}")
-    out.dec
-    out.puts("}")
-    ResultLocalVar(v1)
+
+    var emuType = "int64"
+    val convertedType = compiler.kaitaiType2NativeType(typ)
+    if (convertedType.startsWith("uint")) {
+      emuType = "uint64"
+    } else {
+      emuType = convertedType
+    }
+
+    out.puts(s"var ${localVarName(v1)} $emuType")
+    if (emuType == "*kaitai.BytesTerminatedType" || emuType == "*kaitai.StringTerminatedType") {
+      val translatedTrue = translate(ifTrue)
+      out.puts(s"if ${translate(condition)} {")
+      out.inc
+      out.puts(s"${localVarName(v1)} = $translatedTrue")
+      out.dec
+      out.puts("} else {")
+      out.inc
+      out.puts(s"${localVarName(v1)} = this.New_${translatedTrue.split("\\.").last}TerminatedType(${translate(ifFalse)})")
+      out.dec
+      out.puts("}")
+    } else {
+      // out.puts(s"${localVarName(v1)} = ${localVarName(v1)}")
+      out.puts(s"if ${translate(condition)} {")
+      out.inc
+      out.puts(s"${localVarName(v1)} = ${if (typ.toString.contains("UserType")) translate(ifTrue) else s"$emuType(${translate(ifTrue)})"}")
+      out.dec
+      out.puts("} else {")
+      out.inc
+      out.puts(s"${localVarName(v1)} = ${if (typ.toString.contains("UserType")) translate(ifFalse) else s"$emuType(${translate(ifFalse)})"}")
+      out.dec
+      out.puts("}")
+    }
+    localVarName(v1)
   }
 
-  def trEnumByLabel(enumTypeAbs: List[String], label: String) =
-    ResultString(GoCompiler.enumToStr(enumTypeAbs, label))
-  def trEnumById(enumTypeAbs: List[String], id: String) =
-    ResultString(s"${types2class(enumTypeAbs)}($id)")
+  override def doEnumByLabel(enumTypeAbs: List[String], label: String) = GoCompiler.enumToStr(enumTypeAbs, label)
+  override def doEnumById(enumTypeAbs: List[String], id: String) = s"${types2class(enumTypeAbs)}($id)"
 
-  override def doBytesCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String = {
-    op match {
-      case Ast.cmpop.Eq =>
-        s"Arrays.equals(${translate(left)}, ${translate(right)})"
-      case Ast.cmpop.NotEq =>
-        s"!Arrays.equals(${translate(left)}, ${translate(right)})"
-      case _ =>
-        s"(${GoCompiler.kstreamName}.byteArrayCompare(${translate(left)}, ${translate(right)}) ${cmpOp(op)} 0)"
+  override def doCast(value: Ast.expr, typeName: DataType): String = {
+    val compiler = new GoCompiler(provider.asInstanceOf[ClassTypeProvider], config)
+    if (detectType(value) == typeName || value.isInstanceOf[Ast.expr.IntNum]) {
+      return translate(value)
+    }
+    if (value.isInstanceOf[Ast.expr.FloatNum])
+      s"${compiler.kaitaiType2NativeType(typeName)}(${translate(value)})"
+    else {
+      typeName match {
+        case CalcIntType | CalcFloatType => s"${compiler.kaitaiType2NativeType(typeName)}(${translate(value)})"
+        case _ => compiler.castIfNeeded(translate(value), detectType(value), typeName)
+      }
     }
   }
 
-  override def doCast(value: Ast.expr, typeName: DataType): TranslatorResult = ???
+  override def doArrayLiteral(t: DataType, value: Seq[Ast.expr]) = {
+    val compiler = new GoCompiler(provider.asInstanceOf[ClassTypeProvider], config)
+    s"[]${compiler.kaitaiType2NativeType(t)}{${value.map(translate).mkString(", ")}}"
+  }
 
-  override def doArrayLiteral(t: DataType, value: Seq[Ast.expr]) =
-    ResultString(s"[]${GoCompiler.kaitaiType2NativeType(t)}{${value.map(translate).mkString(", ")}}")
 
-  override def doByteArrayLiteral(arr: Seq[Byte]): TranslatorResult =
-    ResultString("[]uint8{" + arr.map(_ & 0xff).mkString(", ") + "}")
+  override def doByteArrayLiteral(arr: Seq[Byte]): String =
+    "[]uint8{" + arr.map(_ & 0xff).mkString(", ") + "}"
 
-  override def doByteArrayNonLiteral(elts: Seq[Ast.expr]): TranslatorResult =
-    ResultString("[]uint8{" + elts.map(translate).mkString(", ") + "}")
+  override def doByteArrayNonLiteral(elts: Seq[Ast.expr]): String =
+    "[]uint8{" + elts.map(translate).mkString(", ") + "}"
 
   // Predefined methods of various types
 
@@ -296,51 +312,214 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
     "SJIS" -> ("japanese.ShiftJIS", "golang.org/x/text/encoding/japanese"),
     "BIG5" -> ("traditionalchinese.Big5", "golang.org/x/text/encoding/traditionalchinese"),
     "UTF-16LE" -> ("unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM)", "golang.org/x/text/encoding/unicode"),
-    "UTF-16BE" -> ("unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)", "golang.org/x/text/encoding/unicode")
+    "UTF-16BE" -> ("unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM)", "golang.org/x/text/encoding/unicode"),
+    "UTF-8" -> ("unicode.UTF8", "golang.org/x/text/encoding/unicode"),
+    "ASCII" -> ("ianaindex.MIME.Encoding(\"US-ASCII\")", "golang.org/x/text/encoding/ianaindex")
   )
 
-  override def bytesToStr(value: Ast.expr, encoding: String): TranslatorResult =
-    bytesToStr(translate(value), encoding)
+  var terminatedTypesStack: List[() => String] = List()
 
-  def bytesToStr(bytesExpr: String, encoding: String): TranslatorResult = {
-    encoding match {
-      case "ASCII" | "UTF-8" =>
+  override def bytesToStr(value: String, encoding: String): String = {
+    val enc = encoding.stripPrefix("\"").stripSuffix("\"")
+    enc match {
+      case "UTF-8" =>
         // no conversion
         // FIXME: may be add some checks for valid ASCII/UTF-8
-        ResultString(s"string($bytesExpr)")
+        s"string($value)"
       case encStr =>
         ENCODINGS.get(encStr) match {
           case Some((decoderSrc, importName)) =>
             importList.add(importName)
-            outVarCheckRes(s"kaitai.BytesToStr($bytesExpr, $decoderSrc.NewDecoder())")
+            var v = decoderSrc
+            if (decoderSrc.contains("ASCII")) {
+              val r = allocateLocalVar()
+              out.puts(s"decoder$r, _ := $decoderSrc")
+              v = s"decoder$r"
+            }
+            outVarCheckRes(s"kaitai.BytesToStr($value, $v.NewDecoder())")
           case None =>
             throw new RuntimeException(s"encoding '$encStr' in not supported in Go")
         }
     }
   }
 
-//  override def strReverse(s: Ast.expr): String =
-//    s"new StringBuilder(${translate(s)}).reverse().toString()"
-//  override def strSubstring(s: Ast.expr, from: Ast.expr, to: Ast.expr): String =
-//    s"${translate(s)}.substring(${translate(from)}, ${translate(to)})"
+  def rawTerminatedBytesToStr(value: String, rt: StrFromBytesType, id: Identifier): String = {
+    val enc = rt.encoding.stripPrefix("\"").stripSuffix("\"")
+    rt.bytes match {
+      case bt: BytesTerminatedType => {
+        if (bt.terminator == None) {
+          return bytesToStr(value, rt.encoding)
+        }
+        ENCODINGS.get(enc) match {
+          case Some((decoderSrc, importName)) =>
+            if (importName != "") importList.add(importName)
+            terminatedConstructorFact(id, rt, scala.collection.mutable.Map(
+              "encoding"   -> decoderSrc,
+              "terminator" -> bt.terminator,
+              "include"    -> bt.include,
+              "consume"    -> bt.consume,
+              "eosError"   -> bt.eosError
+            ))
+            s"this.New_${idToStr(id)}TerminatedType(string($value))"
+          case None =>
+            throw new RuntimeException(s"encoding '$enc' in not supported in Go")
+        }
+      }
+      case _ => bytesToStr(value, rt.encoding)
+    }
+  }
 
-  override def arrayFirst(a: Ast.expr): TranslatorResult =
-    ResultString(s"${translate(a)}[0]")
-  override def arrayLast(a: Ast.expr): ResultString = {
-    val v = allocateLocalVar()
-    out.puts(s"${localVarName(v)} := ${translate(a)}")
-    ResultString(s"${localVarName(v)}[len(${localVarName(v)}) - 1]")
+  def terminatedConstructorFact(id: Identifier, dt: DataType, params: scala.collection.mutable.Map[String, Any]) = {
+    val compiler = new GoCompiler(provider.asInstanceOf[ClassTypeProvider], config)
+    val idStr = idToStr(id)
+    terminatedTypesStack = terminatedTypesStack.:+(() => {
+      compiler.terminatorConstructor(idStr, dt, params)
+    })
+    null
   }
-  override def arraySize(a: Ast.expr): TranslatorResult =
-    ResultString(s"len(${translate(a)})")
-//  override def arrayMin(a: Ast.expr): String =
-//    s"Collections.min(${translate(a)})"
-//  override def arrayMax(a: Ast.expr): String =
-//    s"Collections.max(${translate(a)})"
 
-  override def userTypeField(ut: UserType, value: Ast.expr, name: String): TranslatorResult = {
-    val valueStr = translate(value)
+  override def strToBytes(value: Ast.expr, encoding: Ast.expr): String = {
+    val strExpr = translate(value)
+    val encodingExpr = translate(encoding)
+    val valueType = detectType(value)
+
+    var strId = strExpr
+    if (strId.contains(".")) {
+      strId = strId.split("\\.").last
+      if (strId.contains("[") && strId.contains("]")) {
+        strId = strId.replace("[", "_").replace("]", "")
+      }
+    } else if (strId.contains("[") && strId.contains("]")) {
+      strId = strId.replace("[", "_").replace("]", "")
+    }
+    valueType match {
+      case sbt if (sbt.isInstanceOf[StrFromBytesType] && sbt.asInstanceOf[StrFromBytesType].bytes.isInstanceOf[BytesTerminatedType]) => {
+        val v = allocateLocalVar()
+        s"wirte${strId}${v}Byte, err := $strExpr.Write();[]byte(wirte${strId}${v}Byte)"
+      }
+      case _ => {
+        encodingExpr.stripPrefix("\"").stripSuffix("\"") match {
+          case "UTF-8" =>
+            // no conversion
+            s"[]byte($strExpr)"
+          case encStr =>
+            ENCODINGS.get(encStr) match {
+              case Some((encoderSrc, importName)) =>
+                importList.add(importName)
+                var v = encoderSrc
+                if (encoderSrc.contains("ASCII")) {
+                  val r = allocateLocalVar()
+                  out.puts(s"encoder$r, _ := $encoderSrc")
+                  v = s"encoder$r"
+                }
+                outVarCheckRes(s"kaitai.StrToBytes($strExpr, $v.NewEncoder())")
+              case None =>
+                throw new RuntimeException(s"encoding '$encStr' in not supported in Go")
+            }
+        }
+      }
+    }
+  }
+
+  override def strReverse(s: Ast.expr): String = {
+    s"kaitai.StringReverse(${translate(s)})"
+  }
+
+  override def strToInt(s: Ast.expr, base: Ast.expr): String = {
+    importList.add("strconv")
+    val sType = detectType(s)
+    val suffix = sType match {
+      case bytesType: StrFromBytesType if bytesType.bytes != None =>
+        ".String()"
+      case _ =>
+        ""
+    }
+
+    outVarCheckRes(s"strconv.ParseInt(${translate(s)}$suffix, ${translate(base)}, 0)")
+  }
+
+  override def strSubstring(s: Ast.expr, from: Ast.expr, to: Ast.expr): String = {
+    val t = detectType(s)
+    s"${terminatedTypeConvert(s, t)}[${translate(from)}:${translate(to)}]"
+  }
+
+  override def arrayFirst(a: Ast.expr): String = {
+    val t = detectType(a)
+    s"${terminatedTypeConvert(a, t)}[0]"
+  }
+
+  override def arrayLast(a: Ast.expr): String = {
+    val t = detectType(a)
+    s"${terminatedTypeConvert(a, t)}[len(${translate(a)}) - 1]"
+  }
+  override def arraySize(a: Ast.expr): String = {
+    val t = detectType(a)
+    s"len(${terminatedTypeConvert(a, t)})"
+  }
+
+  def terminatedTypeConvert(a: Ast.expr, t: DataType) = {
+    val exprRaw = translate(a)
+    if (t.isInstanceOf[BytesTerminatedType]) {
+      val allocatedTempVar = allocateLocalVar()
+      out.puts(s"newBytes${allocatedTempVar}, err := $exprRaw.Write()")
+      returnRes = None
+      outAddErrCheck()
+      out.puts(s"newBytes${allocatedTempVar} = newBytes${allocatedTempVar}")
+      s"newBytes${allocatedTempVar}"
+    } else {
+      if (exprRaw.contains(";")) {
+        val newedExprRaw = exprRaw.split(";")
+        out.puts(newedExprRaw(0))
+        returnRes = None
+        outAddErrCheck()
+        out.puts(s"${newedExprRaw(0).split(",")(0)} = ${newedExprRaw(0).split(",")(0)}")
+        newedExprRaw(1)
+      } else {
+        exprRaw
+      }
+    }
+  }
+
+  def doArray(a: Ast.expr, side: Boolean): String = {
+    val mm = allocateLocalVar()
+    val value = allocateLocalVar()
+    var elemIsTerminatedType = false
+    val t = detectType(a)
+    val translatedA = t match {
+      case _: BytesTerminatedType => {
+        s"${translate(a)}).Bytes()"
+      }
+      case sbt: StrFromBytesType if (sbt.bytes.isInstanceOf[BytesTerminatedType]) => {
+        s"${translate(a)}).String()"
+      }
+      case cat: ArrayType if (cat.elType.isInstanceOf[BytesTerminatedType] || (cat.elType.isInstanceOf[StrFromBytesType] && cat.elType.asInstanceOf[StrFromBytesType].bytes.isInstanceOf[BytesTerminatedType])) => {
+        elemIsTerminatedType = true
+        translate(a)
+      }
+      case _ => translate(a)
+    }
+
+    out.puts(s"${localVarName(mm)} := $translatedA[0]")
+    out.puts(s"for _, ${localVarName(value)} := range $translatedA {")
+    out.inc
+    out.puts(s"if ${localVarName(mm)}${if (elemIsTerminatedType) ".String()" else ""} ${if (side) ">" else "<"} ${localVarName(value)}${if (elemIsTerminatedType) ".String()" else ""} {")
+    out.inc
+    out.puts(s"${localVarName(mm)} = ${localVarName(value)}")
+    out.dec
+    out.puts("}")
+    out.dec
+    out.puts("}")
+    localVarName(mm)
+  }
+
+  override def arrayMin(a: Ast.expr): String = doArray(a, side = true)
 
+  override def arrayMax(a: Ast.expr): String = doArray(a, side = false)
+
+
+  override def userTypeField(ut: UserType, value: Ast.expr, name: String): String = {
+    val compiler = new GoCompiler(provider.asInstanceOf[ClassTypeProvider], config)
+    var valueStr = translate(value)
     val (call, twoOuts) = name match {
       case Identifier.ROOT |
            Identifier.PARENT |
@@ -349,14 +528,30 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
       case _ =>
         (Utils.upperCamelCase(name), provider.isLazy(ut.classSpec.get, name))
     }
+    if (value.isInstanceOf[Ast.expr.CastToType]) {
+      valueStr = s"$valueStr.(${compiler.kaitaiType2NativeType(ut)})"
+    }
 
     if (twoOuts) {
-      outVarCheckRes(s"$valueStr.$call()")
+      val name = outVarCheckRes(s"$valueStr.Get${call.charAt(0).toLower + call.substring(1)}()")
+      out.puts(s"$name = $name")
+      name
     } else {
-      ResultString(s"$valueStr.$call")
+      var suffix = ""
+      ut.classSpec.get.seq.foreach(f => {
+         if (f.id.humanReadable == name && detectType(value) != ut) {
+           if (f.dataType.isInstanceOf[StrFromBytesType] && f.dataType.asInstanceOf[StrFromBytesType].bytes != null && f.dataType.asInstanceOf[StrFromBytesType].bytes.isInstanceOf[BytesTerminatedType]) {
+             suffix = ".String()"
+           } else if (f.dataType.isInstanceOf[BytesTerminatedType]) {
+             suffix = ".Bytes()"
+           }
+         }
+      })
+      s"$valueStr.$call$suffix"
     }
   }
-  def kaitaiStructField(value: Ast.expr, name: String): TranslatorResult = {
+
+  override def kaitaiStructField(value: Ast.expr, name: String): String = {
     val valueStr = translate(value)
 
     val (call, twoOuts) = name match {
@@ -369,35 +564,28 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
     if (twoOuts) {
       outVarCheckRes(s"$valueStr.$call()")
     } else {
-      ResultString(s"$valueStr.$call")
+      s"$valueStr.$call"
     }
   }
 
-  override def strLength(s: Ast.expr): TranslatorResult = {
+  override def strLength(s: Ast.expr): String = {
     importList.add("unicode/utf8")
-    ResultString(s"utf8.RuneCountInString(${translate(s)})")
-  }
-
-  override def strReverse(s: Ast.expr): TranslatorResult = {
-    ResultString(s"kaitai.StringReverse(${translate(s)})")
-  }
-
-  override def strToInt(s: Ast.expr, base: Ast.expr): TranslatorResult = {
-    importList.add("strconv")
-    outVarCheckRes(s"strconv.ParseInt(${translate(s)}, ${translate(base)}, 0)")
-  }
 
-  override def strSubstring(s: Ast.expr, from: Ast.expr, to: Ast.expr): TranslatorResult = {
-    ResultString(s"${translate(s)}[${translate(from)}:${translate(to)}]")
+    val sType = detectType(s)
+    sType match {
+      case sbt: StrFromBytesType if sbt.bytes != null && sbt.bytes.isInstanceOf[BytesTerminatedType] =>
+        s"utf8.RuneCountInString(${translate(s)}.String())"
+      case _ =>
+        s"utf8.RuneCountInString(${translate(s)})"
+    }
   }
 
-  override def intToStr(value: Ast.expr, base: Ast.expr): TranslatorResult = {
+  override def intToStr(value: Ast.expr, base: Ast.expr): String = {
     importList.add("strconv")
-    ResultString(s"strconv.FormatInt(int64(${translate(value)}), ${translate(base)})")
+    s"strconv.FormatInt(int64(${translate(value)}), ${translate(base)})"
   }
 
-  override def floatToInt(value: Ast.expr) =
-    ResultString(s"int(${translate(value)})")
+  override def floatToInt(value: Ast.expr) = s"int(${translate(value)})"
 
   override def kaitaiStreamSize(value: Ast.expr) =
     outVarCheckRes(s"${translate(value)}.Size()")
@@ -408,76 +596,61 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
   override def kaitaiStreamPos(value: Ast.expr) =
     outVarCheckRes(s"${translate(value)}.Pos()")
 
-  override def arrayMin(a: Ast.expr): ResultLocalVar = {
-    val min = allocateLocalVar()
-    val value = allocateLocalVar()
-    out.puts(s"${localVarName(min)} := ${translate(a)}[0]")
-    out.puts(s"for _, ${localVarName(value)} := range ${translate(a)} {")
-    out.inc
-    out.puts(s"if ${localVarName(min)} > ${localVarName(value)} {")
-    out.inc
-    out.puts(s"${localVarName(min)} = ${localVarName(value)}")
-    out.dec
-    out.puts("}")
-    out.dec
-    out.puts("}")
-    ResultLocalVar(min)
-  }
-
-  override def arrayMax(a: Ast.expr): ResultLocalVar = {
-    val max = allocateLocalVar()
-    val value = allocateLocalVar()
-    out.puts(s"${localVarName(max)} := ${translate(a)}[0]")
-    out.puts(s"for _, ${localVarName(value)} := range ${translate(a)} {")
-    out.inc
-    out.puts(s"if ${localVarName(max)} < ${localVarName(value)} {")
-    out.inc
-    out.puts(s"${localVarName(max)} = ${localVarName(value)}")
-    out.dec
-    out.puts("}")
-    out.dec
-    out.puts("}")
-    ResultLocalVar(max)
-  }
 
-  override def enumToInt(value: Ast.expr, et: EnumType) =
-    translateExpr(value)
+  override def enumToInt(value: Ast.expr, et: EnumType) = translate(value)
 
-  override def boolToInt(value: Ast.expr): ResultLocalVar = {
+  override def boolToInt(value: Ast.expr): String = {
     val v = allocateLocalVar()
-    out.puts(s"${localVarName(v)} := 0")
+    out.puts(s"var ${localVarName(v)} uint64 = 0")
     out.puts(s"if ${translate(value)} {")
     out.inc
     out.puts(s"${localVarName(v)} = 1")
     out.dec
     out.puts("}")
-    ResultLocalVar(v)
+    localVarName(v)
   }
 
-  def userType(t: UserType, io: String) = {
+  def userType(t: UserType, io: String): String = {
     val v = allocateLocalVar()
     val parent = t.forcedParent match {
       case Some(USER_TYPE_NO_PARENT) => "nil"
       case Some(fp) => translate(fp)
-      case None => "this"
+      case None => {
+        val content = t.classSpec.get.parentClass match {
+          case _: ClassSpec => {
+            if (t.classSpec.get.isTopLevel) {
+              "&this.Stream"
+            } else {
+              "this"
+            }
+          }
+          case MultiParentClassSpec => "nil"
+          case _ => "&this.Stream"
+        }
+        content
+      }
     }
-    val root = if (t.isOpaque) "nil" else "this._root"
-    val addParams = t.args.map((a) => translate(a)).mkString(", ")
-    out.puts(s"${localVarName(v)} := New${GoCompiler.types2class(t.classSpec.get.name)}($addParams)")
-    out.puts(s"err = ${localVarName(v)}.Read($io, $parent, $root)")
+
+    var root = "this._root"
+    out.puts(s"${localVarName(v)} := New${GoCompiler.types2class(t.classSpec.get.name)}($io, $parent, $root)")
+    localVarName(v)
+  }
+
+  def userTypeRead(expr: String) = {
+    out.puts(s"err = ${expr}.Read()")
     outAddErrCheck()
-    ResultLocalVar(v)
   }
 
-  def outVarCheckRes(expr: String): ResultLocalVar = {
+  def outVarCheckRes(expr: String): String = {
     val v1 = allocateLocalVar()
     out.puts(s"${localVarName(v1)}, err := $expr")
     outAddErrCheck()
-    ResultLocalVar(v1)
+    // out.puts(s"${localVarName(v1)} = ${localVarName(v1)}")
+    localVarName(v1)
   }
 
-  def outTransform(id: ResultLocalVar, expr: String): ResultLocalVar = {
-    out.puts(s"${resToStr(id)} = $expr")
+  def outTransform(id: String, expr: String): String = {
+    out.puts(s"${id} = $expr")
     id
   }
 
@@ -489,8 +662,13 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
     localVarNum
   }
 
+  def getNowLocalVarName() = s"tmp$localVarNum"
+
   def localVarName(n: Int) = s"tmp$n"
 
+  def handleUnfinsiedSizeExpr(sizeExpr: String): Unit =
+    out.puts(s"_ = $sizeExpr")
+
   def outAddErrCheck() {
     out.puts("if err != nil {")
     out.inc
@@ -505,6 +683,78 @@ class GoTranslator(out: StringLanguageOutputWriter, provider: TypeProvider, impo
     out.puts("}")
   }
 
-  override def byteSizeOfValue(attrName: String, valType: DataType): TranslatorResult =
-    trIntLiteral(CommonSizeOf.bitToByteSize(CommonSizeOf.getBitsSizeOfType(attrName, valType)))
+  override def byteSizeOfValue(attrName: String, valType: DataType): String =
+    doIntLiteral(CommonSizeOf.bitToByteSize(CommonSizeOf.getBitsSizeOfType(attrName, valType)))
+
+  def interfaceTypeOfSwitchCase(transStr: String, targetType: String): String = {
+    val transVar = allocateLocalVar()
+    val tmpVarName = localVarName(transVar)
+    out.puts(s"${tmpVarName}, ok := $transStr.($targetType)")
+    out.puts("if !ok {")
+    out.inc
+    out.puts("return nil")
+    out.dec
+    out.puts("}")
+
+    tmpVarName
+  }
+
+  def interfaceTypeOfSwitchCaseInExpr(expr: Ast.expr, dataType: Option[DataType], typeTransCallBack: (DataType) => String): (Ast.expr, String) = {
+    var changedExpr = expr
+    var tmpName = ""
+    expr match {
+      case call: Ast.expr.Attribute => {
+        val value = call.value
+
+        value match {
+          case ct: Ast.expr.CastToType => {
+            val dt = detectType(value)
+            val nativeType = typeTransCallBack(dt)
+            val transVar = allocateLocalVar()
+            val tmpVarName = localVarName(transVar)
+            out.puts(s"${tmpVarName}, ok := ${translate(value)}.($nativeType)")
+            out.puts("if !ok {")
+            out.inc
+            out.puts("return nil")
+            out.dec
+            out.puts("}")
+
+            changedExpr = Ast.expr.Attribute(Ast.expr.Str(tmpVarName), call.attr)
+            tmpName = tmpVarName
+          }
+          case _ => {}
+        }
+      }
+      case name: Ast.expr.InternalName => {
+        val nativeType = typeTransCallBack(dataType.get)
+        val transVar = allocateLocalVar()
+        val tmpVarName = localVarName(transVar)
+        out.puts(s"${tmpVarName}, ok := ${translate(name)}.($nativeType)")
+        out.puts("if !ok {")
+        out.inc
+        out.puts("return nil")
+        out.dec
+        out.puts("}")
+
+        changedExpr = name
+        tmpName = tmpVarName
+      }
+      case subsacript: Ast.expr.Subscript => {
+        val nativeType = typeTransCallBack(dataType.get)
+        val transVar = allocateLocalVar()
+        val tmpVarName = localVarName(transVar)
+        out.puts(s"${tmpVarName}, ok := ${translate(subsacript)}.($nativeType)")
+        out.puts("if !ok {")
+        out.inc
+        out.puts("return nil")
+        out.dec
+        out.puts("}")
+
+        changedExpr = subsacript
+        tmpName = tmpVarName
+      }
+      case _ => {}
+    }
+    (changedExpr, tmpName)
+  }
 }
diff --git a/shared/src/main/scala/io/kaitai/struct/translators/JavaTranslator.scala b/shared/src/main/scala/io/kaitai/struct/translators/JavaTranslator.scala
index 5130a069f..8ccaf6781 100644
--- a/shared/src/main/scala/io/kaitai/struct/translators/JavaTranslator.scala
+++ b/shared/src/main/scala/io/kaitai/struct/translators/JavaTranslator.scala
@@ -1,6 +1,6 @@
 package io.kaitai.struct.translators
 
-import io.kaitai.struct.{ImportList, Utils}
+import io.kaitai.struct.{ClassTypeProvider, ImportList, RuntimeConfig, Utils}
 import io.kaitai.struct.exprlang.Ast
 import io.kaitai.struct.exprlang.Ast._
 import io.kaitai.struct.datatype.DataType
@@ -8,7 +8,7 @@ import io.kaitai.struct.datatype.DataType._
 import io.kaitai.struct.format.Identifier
 import io.kaitai.struct.languages.JavaCompiler
 
-class JavaTranslator(provider: TypeProvider, importList: ImportList) extends BaseTranslator(provider) {
+class JavaTranslator(provider: TypeProvider, importList: ImportList, config: RuntimeConfig) extends BaseTranslator(provider) {
   override def doIntLiteral(n: BigInt): String = {
     // Java's integer parsing behaves differently depending on whether you use decimal or hex syntax.
     // With decimal syntax, the parser/compiler rejects any number that cannot be stored in a long
@@ -32,7 +32,10 @@ class JavaTranslator(provider: TypeProvider, importList: ImportList) extends Bas
   }
 
   override def doArrayLiteral(t: DataType, value: Seq[expr]): String = {
-    val javaType = JavaCompiler.kaitaiType2JavaTypeBoxed(t)
+    // FIXME
+    val compiler = new JavaCompiler(provider.asInstanceOf[ClassTypeProvider], config)
+
+    val javaType = compiler.kaitaiType2JavaTypeBoxed(t)
     val commaStr = value.map((v) => translate(v)).mkString(", ")
 
     importList.add("java.util.ArrayList")
@@ -54,6 +57,12 @@ class JavaTranslator(provider: TypeProvider, importList: ImportList) extends Bas
     }
   }
 
+  override def doNumericCompareOp(left: expr, op: cmpop, right: expr): String =
+    s"(${super.doNumericCompareOp(left, op, right)})"
+
+  override def doEnumCompareOp(left: expr, op: cmpop, right: expr): String =
+    s"(${super.doEnumCompareOp(left, op, right)})"
+
   override def doName(s: String) =
     s match {
       case Identifier.ITERATOR => "_it"
@@ -99,11 +108,19 @@ class JavaTranslator(provider: TypeProvider, importList: ImportList) extends Bas
   }
 
   override def arraySubscript(container: expr, idx: expr): String =
-    s"${translate(container)}.get((int) ${translate(idx)})"
+    s"${translate(container)}.get(${doCast(idx, CalcIntType)})"
   override def doIfExp(condition: expr, ifTrue: expr, ifFalse: expr): String =
     s"(${translate(condition)} ? ${translate(ifTrue)} : ${translate(ifFalse)})"
-  override def doCast(value: Ast.expr, typeName: DataType): String =
-    s"((${JavaCompiler.kaitaiType2JavaType(typeName)}) (${translate(value)}))"
+  override def doCast(value: Ast.expr, typeName: DataType): String = {
+    // FIXME
+    val compiler = new JavaCompiler(provider.asInstanceOf[ClassTypeProvider], config)
+    if (value.isInstanceOf[Ast.expr.IntNum] || value.isInstanceOf[Ast.expr.FloatNum])
+      // this branch is not really needed, but makes the code a bit cleaner -
+      // we can simplify casting to just this for numeric constants
+      s"((${compiler.kaitaiType2JavaType(typeName)}) ${translate(value)})"
+    else
+      compiler.castIfNeeded(translate(value), AnyType, typeName)
+  }
 
   // Predefined methods of various types
   override def strToInt(s: expr, base: expr): String =
@@ -111,7 +128,7 @@ class JavaTranslator(provider: TypeProvider, importList: ImportList) extends Bas
   override def enumToInt(v: expr, et: EnumType): String =
     s"${translate(v)}.id()"
   override def floatToInt(v: expr): String =
-    s"(int) (${translate(v)} + 0)"
+    doCast(v, CalcIntType)
   override def intToStr(i: expr, base: expr): String =
     s"Long.toString(${translate(i)}, ${translate(base)})"
   override def bytesToStr(bytesExpr: String, encoding: String): String = {
@@ -136,26 +153,39 @@ class JavaTranslator(provider: TypeProvider, importList: ImportList) extends Bas
     }
     s"new String($bytesExpr, $charsetExpr)"
   }
+  override def bytesIndexOf(b: expr, byte: expr): String =
+    s"${JavaCompiler.kstreamName}.byteArrayIndexOf(${translate(b)}, ${doCast(byte, Int1Type(true))})"
 
   override def bytesLength(b: Ast.expr): String =
     s"${translate(b)}.length"
   override def bytesSubscript(container: Ast.expr, idx: Ast.expr): String =
-    s"${translate(container)}[${translate(idx)}]"
+    s"(${translate(container)}[${doCast(idx, CalcIntType)}] & 0xff)"
   override def bytesFirst(b: Ast.expr): String =
-    s"${translate(b)}[0]"
+    bytesSubscript(b, Ast.expr.IntNum(0))
   override def bytesLast(b: Ast.expr): String =
-    s"${translate(b)}[(${translate(b)}).length - 1]"
+    bytesSubscript(b, Ast.expr.BinOp(
+      Ast.expr.Attribute(
+        b,
+        Ast.identifier("length")
+      ),
+      Ast.operator.Sub,
+      Ast.expr.IntNum(1)
+    ))
   override def bytesMin(b: Ast.expr): String =
     s"${JavaCompiler.kstreamName}.byteArrayMin(${translate(b)})"
   override def bytesMax(b: Ast.expr): String =
     s"${JavaCompiler.kstreamName}.byteArrayMax(${translate(b)})"
 
   override def strLength(s: expr): String =
-    s"${translate(s)}.length()"
+    s"(${translate(s)}).length()"
   override def strReverse(s: expr): String =
     s"new StringBuilder(${translate(s)}).reverse().toString()"
   override def strSubstring(s: expr, from: expr, to: expr): String =
-    s"${translate(s)}.substring(${translate(from)}, ${translate(to)})"
+    s"(${translate(s)}).substring(${translate(from)}, ${translate(to)})"
+  override def strToBytes(s: expr, encoding: expr): String = {
+    importList.add("java.nio.charset.Charset")
+    s"(${translate(s)}).getBytes(Charset.forName(${translate(encoding)}))"
+  }
 
   override def arrayFirst(a: expr): String =
     s"${translate(a)}.get(0)"
diff --git a/shared/src/main/scala/io/kaitai/struct/translators/PythonTranslator.scala b/shared/src/main/scala/io/kaitai/struct/translators/PythonTranslator.scala
index 2a4e21f81..0991ab0d2 100644
--- a/shared/src/main/scala/io/kaitai/struct/translators/PythonTranslator.scala
+++ b/shared/src/main/scala/io/kaitai/struct/translators/PythonTranslator.scala
@@ -16,6 +16,18 @@ class PythonTranslator(provider: TypeProvider, importList: ImportList) extends B
     }
   }
 
+  override def doNumericCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String =
+    s"(${super.doNumericCompareOp(left, op, right)})"
+
+  override def doStrCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String =
+    s"(${super.doStrCompareOp(left, op, right)})"
+
+  override def doEnumCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String =
+    s"(${super.doEnumCompareOp(left, op, right)})"
+
+  override def doBytesCompareOp(left: Ast.expr, op: Ast.cmpop, right: Ast.expr): String =
+    s"(${super.doBytesCompareOp(left, op, right)})"
+
   override def doStringLiteral(s: String): String = "u" + super.doStringLiteral(s)
   override def doBoolLiteral(n: Boolean): String = if (n) "True" else "False"
 
@@ -104,6 +116,8 @@ class PythonTranslator(provider: TypeProvider, importList: ImportList) extends B
   }
   override def bytesToStr(bytesExpr: String, encoding: String): String =
     s"""($bytesExpr).decode("$encoding")"""
+  override def bytesIndexOf(b: Ast.expr, byte: Ast.expr): String =
+    s"${PythonCompiler.kstreamName}.byte_array_index_of(${translate(b)}, ${translate(byte)})"
 
   override def bytesLength(value: Ast.expr): String =
     s"len(${translate(value)})"
@@ -125,6 +139,8 @@ class PythonTranslator(provider: TypeProvider, importList: ImportList) extends B
     s"(${translate(value)})[::-1]"
   override def strSubstring(s: Ast.expr, from: Ast.expr, to: Ast.expr): String =
     s"(${translate(s)})[${translate(from)}:${translate(to)}]"
+  override def strToBytes(s: Ast.expr, encoding: Ast.expr): String =
+    s"(${translate(s)}).encode(${translate(encoding)})"
 
   override def arrayFirst(a: Ast.expr): String =
     s"${translate(a)}[0]"
diff --git a/shared/src/main/scala/io/kaitai/struct/translators/TypeDetector.scala b/shared/src/main/scala/io/kaitai/struct/translators/TypeDetector.scala
index 5b017772c..839807ad4 100644
--- a/shared/src/main/scala/io/kaitai/struct/translators/TypeDetector.scala
+++ b/shared/src/main/scala/io/kaitai/struct/translators/TypeDetector.scala
@@ -249,7 +249,9 @@ class TypeDetector(provider: TypeProvider) {
         (objType, methodName.name) match {
           case (_: StrType, "substring") => CalcStrType
           case (_: StrType, "to_i") => CalcIntType
+          case (_: StrType, "to_b") => CalcBytesType
           case (_: BytesType, "to_s") => CalcStrType
+          case (_: BytesType, "index_of") => CalcIntType
           case _ =>
             throw new MethodNotFoundError(methodName.name, objType)
         }
@@ -387,21 +389,15 @@ object TypeDetector {
               if (t1.name == t2.name) {
                 t1
               } else {
-                if (t1.isOwning || t2.isOwning) {
-                  KaitaiStructType
-                } else {
-                  CalcKaitaiStructType()
-                }
+                // TODO: in go, only interface{} (like enum) can trans to other type, so
+                // change here
+                CalcAnyType
               }
             case (Some(cs1), Some(cs2)) =>
               if (cs1 == cs2) {
                 t1
               } else {
-                if (t1.isOwning || t2.isOwning) {
-                  KaitaiStructType
-                } else {
-                  CalcKaitaiStructType()
-                }
+                CalcAnyType
               }
             case (_, _) =>
               if (t1.isOwning || t2.isOwning) {
@@ -422,10 +418,10 @@ object TypeDetector {
             t.enumSpec = t1.enumSpec
             t
           } else {
-            AnyType
+            CalcAnyType
           }
         case (a1: ArrayType, a2: ArrayType) => CalcArrayType(combineTypesAndFail(a1.elType, a2.elType))
-        case _ => AnyType
+        case _ => CalcAnyType
       }
     }
   }