set fout [open [file join $vfspath packages.tcl] w]
  puts $fout [list set dir $::KIT(PKGPREFIX)]
  set buffer [::practcl::pkgindex_path $::KIT(BASEVFS) $vfspath]
  puts $fout $buffer

  close $fout
  ::practcl::copyDir $::KIT(BASEVFS) $vfspath
  #::practcl::copyDir $::KIT(PKGROOT)$::KIT(PKGPREFIX)/lib $vfspath/boot/pkgs
  foreach arg $args {
     ::practcl::copyDir $arg $vfspath
  }
  ::zipfile::mkzip::mkzip ${name}$::KIT(EXEEXT) -runtime $::TARGET(tclkit_bare) -directory $vfspath
  if { $::KIT(platform) ne "windows" } {
    file attributes ${name}$::KIT(EXEEXT) -permissions a+x
  }

  exec [info nameofexecutable] [file join $HERE autosetup autosetup]
  cd $PWD
}

###
# Can *almost* get it working, but the broken installer
# leads to chaos under MinGW


###
set ::KIT(PACKAGES) {
  thread {tag release}
  sqlite {tag release}
  udp {tag trunk}
  canvas3d {tag trunk tk 1}
  tkimg    {tag trunk tk 1 broken_destroot 1}
}

source [file join $::HERE odieConfig.tcl]
set ::KIT(platform) $::odie(platform)
set ::KIT(ORIG_TCL_SRC_DIR) $::odie_tcl(src_dir)
set ::KIT(ORIG_TK_SRC_DIR) $::odie_tk(src_dir)
set ::KIT(TCL_BUILD_OPTS) $::odie_tcl(config_flags)

  toadkit {
    set build(toadkit) 1
  }
  basekit {
    set build(toadkit) 1
  }
  packages {
    set build(packages) 1
    set build(packages) 1
  }
  wrap {
    
  }
  clean {
  }

}
if {![file exists $::KIT(PKGROOT)]} {
  set build(packages) 1
}
if {![file exists $::KIT(BASEVFS)]} {
  set build(basekitvfs) 1
}
if {$build(packages)} {
  set build(basekitvfs) 1
}
if {$build(tcl) || $build(tk) || $build(toadkit)} {
  set build(packages) 1
  set build(basekitvfs) 1
  set build(toadkit.rc) 1
  set build(tclkit_bare) 1
  set build(libtoadkit.a) 1
}

  # Link together our executable
  ###
  doexec ar cr $::TARGET(libtoadkit.a) {*}$::KIT(LIBTOADKIT_OBJS)
  doexec ranlib $::TARGET(libtoadkit.a)
}

if {$build(packages)} {
  ###
  # Clean out any packages stuffed in the path where packages that
  # don't handle DESTROOT properly
  ###
  if {$::KIT(PKGPREFIX) in {/usr / /usr/local /opt /opt/local /tcl}} {
    set BROKENROOT {}
  } else {
    catch {
    set BROKENROOT [::practcl::msys_to_tclpath $::KIT(PKGPREFIX)]
    puts "BROKENROOT $BROKENROOT"
    file delete $BROKENROOT
    }
  }
  ###
  # Clean out our installed package file system
  ###
  if {[file exists $::KIT(PKGROOT)]} {
    file delete -force $::KIT(PKGROOT)
  }
  cd $PWD
  set fossilinfo [list download $::KIT(DOWNLOAD) sandbox $::KIT(SANDBOX)]
  set tclconfiginfo [::practcl::fossil_sandbox tclconfig [dict merge $fossilinfo {}]]
  set tclconfig_path [dict get $tclconfiginfo srcroot]
  foreach {pkg info} $::KIT(PACKAGES) {
    set pkginfo [::practcl::fossil_sandbox $pkg [dict merge $fossilinfo $info]]
    set pkgpath [dict get $pkginfo srcroot]
    puts [list BUILDING $pkg in $pkgpath]

      } else {
        continue
      }
    }
    puts "INSTALLING to VFS [file tail $pkgpath]"
    domake install DESTDIR=$::KIT(PKGROOT)
  }

  if {$::KIT(PKGPREFIX) in {/usr / /usr/local /opt /opt/local /tcl}} {
    set BROKENROOT {}
  } else {
    catch {
    set BROKENROOT [::practcl::msys_to_tclpath $::KIT(PKGPREFIX)]
    puts [list COPY $BROKENROOT -> $::KIT(PKGROOT)$::KIT(PKGPREFIX)]
    ::practcl::copyDir $BROKENROOT $::KIT(PKGROOT)$::KIT(PKGPREFIX)
    file delete -force $BROKENROOT
    }
  }
}

if {$build(tclkit_bare)} {
  cd $PWD
  # Build a Tcl-only shell
  set cmd [list $::KIT(cc)  {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags)]
  lappend cmd {*}$::KIT(TCLSHELL_OBJS)
  foreach item [glob ${_TclSrcDir}/*.a] {
    lappend cmd $item
  }
  lappend cmd $::TARGET(libtoadkit.a) {*}$::TCL(libs)
  lappend cmd -o $::TARGET(tclkit_bare) {*}$::KIT(LDFLAGS_CONSOLE)
  doexec {*}$cmd
}

if {$build(basekitvfs)} {
  cd $PWD
  if {[file exists $::KIT(BASEVFS)]} {
    file delete -force $::KIT(BASEVFS)
  }
  puts "***
*** BASE KIT VFS PACKAGES
***"
  puts [list COPY [file join $::KIT(PKGROOT) [string trimleft $::KIT(PKGPREFIX) /] lib]]
  ::practcl::copyDir [file join $::KIT(PKGROOT) [string trimleft $::KIT(PKGPREFIX) /] lib] [file join $::KIT(BASEVFS) boot pkgs]
  ::practcl::copyDir [file join $::KIT(TCLSRCDIR) library] [file join $::KIT(BASEVFS) boot tcl]
  if { $::KIT(platform) eq "windows" } {
    set ddedll [glob -nocomplain [file join $_TclSrcDir tcldde*.dll]]
    if {$ddedll != {}} {
      file copy $ddedll [file join $::KIT(BASEVFS) boot tcl dde]
    }
    set regdll [glob -nocomplain [file join $_TclSrcDir tclreg*.dll]]