diff --git a/ponsim/v2/ponsim.go b/ponsim/v2/ponsim.go
new file mode 100644
index 0000000..fad0972
--- /dev/null
+++ b/ponsim/v2/ponsim.go
@@ -0,0 +1,289 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"github.com/opencord/voltha/ponsim/v2/common"
+	"github.com/opencord/voltha/ponsim/v2/core"
+	"github.com/opencord/voltha/ponsim/v2/grpc"
+	"log"
+	"os"
+	"os/signal"
+	"path"
+)
+
+// TODO: Cleanup logs
+
+const (
+	default_name           = "PON"
+	default_grpc_port      = 50060
+	default_grpc_addr      = ""
+	default_device_type    = "OLT"
+	default_api_type       = "PONSIM"
+	default_internal_if    = "eth0"
+	default_external_if    = "eth1"
+	default_onus           = 1
+	default_alarm_sim      = false
+	default_alarm_freq     = 60
+	default_quiet          = false
+	default_verbose        = false
+	default_no_banner      = false
+	default_parent_addr    = "olt"
+	default_parent_port    = 50060
+	default_vcore_endpoint = "vcore"
+	default_fluentd_host   = ""
+
+	default_snapshot_len = 65535
+	default_promiscuous  = false
+
+	default_voltha_key  = "pki/voltha.key"
+	default_voltha_cert = "pki/voltha.crt"
+	default_voltha_ca   = "pki/voltha-CA.pem"
+)
+
+var (
+	voltha_base = os.Getenv("VOLTHA_BASE")
+	certs       *grpc.GrpcSecurity
+
+	name           string = default_name + "_" + device_type
+	grpc_port      int    = default_grpc_port
+	grpc_addr      string = default_grpc_addr
+	device_type    string = default_device_type
+	api_type       string = default_api_type
+	internal_if    string = default_internal_if
+	external_if    string = default_external_if
+	onus           int    = default_onus
+	alarm_sim      bool   = default_alarm_sim
+	alarm_freq     int    = default_alarm_freq
+	quiet          bool   = default_quiet
+	verbose        bool   = default_verbose
+	no_banner      bool   = default_no_banner
+	voltha_key     string = default_voltha_key
+	voltha_cert    string = default_voltha_cert
+	voltha_ca      string = default_voltha_ca
+	parent_addr    string = default_parent_addr
+	parent_port    int    = default_parent_port
+	vcore_endpoint string = default_vcore_endpoint
+	fluentd_host   string = default_fluentd_host
+
+	snapshot_len int32 = default_snapshot_len
+	promiscuous  bool  = default_promiscuous
+)
+
+func init() {
+	parseArgs()
+
+	// Enable fluentd support
+	if fluentd_host != "" {
+		common.Logger().SetFluentd(fluentd_host)
+	}
+
+	// Print banner unless no_banner is specified
+	if !no_banner {
+		printBanner()
+	}
+}
+
+func parseArgs() {
+	var help string
+
+	help = fmt.Sprintf("Name of the PON device")
+	flag.StringVar(&grpc_addr, "name", default_name, help)
+
+	help = fmt.Sprintf("Address used to establish GRPC server connection")
+	flag.StringVar(&grpc_addr, "grpc_addr", default_grpc_addr, help)
+
+	help = fmt.Sprintf("Port used to establish GRPC server connection")
+	flag.IntVar(&grpc_port, "grpc_port", default_grpc_port, help)
+
+	help = fmt.Sprintf("Type of device to simulate (OLT or ONU)")
+	flag.StringVar(&device_type, "device_type", default_device_type, help)
+
+	help = fmt.Sprintf("Type of API used to communicate with devices (PONSIM or BAL)")
+	flag.StringVar(&api_type, "api_type", default_api_type, help)
+
+	help = fmt.Sprintf("Internal Communication Interface for read/write network traffic")
+	flag.StringVar(&internal_if, "internal_if", default_internal_if, help)
+
+	help = fmt.Sprintf("External Communication Interface for read/write network traffic")
+	flag.StringVar(&external_if, "external_if", default_external_if, help)
+
+	help = fmt.Sprintf("Enable promiscuous mode on network interfaces")
+	flag.BoolVar(&promiscuous, "promiscuous", default_promiscuous, help)
+
+	help = fmt.Sprintf("Number of ONUs to simulate")
+	flag.IntVar(&onus, "onus", default_onus, help)
+
+	help = fmt.Sprintf("Suppress debug and info logs")
+	flag.BoolVar(&quiet, "quiet", default_quiet, help)
+
+	help = fmt.Sprintf("Enable verbose logging")
+	flag.BoolVar(&verbose, "verbose", default_verbose, help)
+
+	help = fmt.Sprintf("Omit startup banner log lines")
+	flag.BoolVar(&no_banner, "no_banner", default_no_banner, help)
+
+	help = fmt.Sprintf("Enable generation of simulated alarms")
+	flag.BoolVar(&alarm_sim, "alarm_sim", default_alarm_sim, help)
+
+	help = fmt.Sprintf("Frequency of simulated alarms (in seconds)")
+	flag.IntVar(&alarm_freq, "alarm_freq", default_alarm_freq, help)
+
+	help = fmt.Sprintf("Address of OLT to connect to")
+	flag.StringVar(&parent_addr, "parent_addr", default_parent_addr, help)
+
+	help = fmt.Sprintf("Port of OLT to connect to")
+	flag.IntVar(&parent_port, "parent_port", default_parent_port, help)
+
+	help = fmt.Sprintf("Voltha core endpoint address")
+	flag.StringVar(&vcore_endpoint, "vcore_endpoint", default_vcore_endpoint, help)
+
+	help = fmt.Sprintf("Fluentd host address")
+	flag.StringVar(&fluentd_host, "fluentd", default_fluentd_host, help)
+
+	flag.Parse()
+}
+
+func printBanner() {
+	log.Println("    ____  ____  _   _______ ______  ___")
+	log.Println("   / __ \\/ __ \\/ | / / ___//  _/  |/  /")
+	log.Println("  / /_/ / / / /  |/ /\\__ \\ / // /|_/ / ")
+	log.Println(" / ____/ /_/ / /|  /___/ // // /  / /  ")
+	log.Println("/_/    \\____/_/ |_//____/___/_/  /_/  ")
+
+	switch device_type {
+	case "OLT":
+		printOltBanner()
+	case "ONU":
+		printOnuBanner()
+	}
+
+	log.Println("(to stop: press Ctrl-C)")
+}
+func printOltBanner() {
+	log.Println("   ____  __  ______")
+	log.Println("  / __ \\/ / /_  __/")
+	log.Println(" / / / / /   / /   ")
+	log.Println("/ /_/ / /___/ /    ")
+	log.Println("\\____/_____/_/     ")
+}
+func printOnuBanner() {
+	log.Println("   ____  _   ____  __")
+	log.Println("  / __ \\/ | / / / / /")
+	log.Println(" / / / /  |/ / / / / ")
+	log.Println("/ /_/ / /|  / /_/ /  ")
+	log.Println("\\____/_/ |_/\\____/   ")
+}
+
+/*
+-----------------------------------------------------------------
+*/
+type PonSimService struct {
+	device core.PonSimInterface
+	server *grpc.GrpcServer
+}
+
+func (s *PonSimService) Start(ctx context.Context) {
+	// GRPC server needs to be secure.
+	// Otherwise communication between adapter and simulator does not occur
+	s.server = grpc.NewGrpcServer(s.device.GetAddress(), s.device.GetPort(), certs, true)
+
+	// Add GRPC services
+	s.server.AddCommonService(s.device)
+	s.server.AddPonSimService(s.device)
+
+	// Add OLT specific services
+	if device_type == core.OLT.String() {
+		s.server.AddOltService(s.device)
+	}
+
+	// Add XPON services unless using BAL
+	if api_type == core.PONSIM.String() {
+		s.server.AddXPonService()
+	} else {
+		s.server.AddBalService()
+	}
+
+	// Start the GRPC server
+	go s.server.Start(ctx)
+
+	// Start the PON device
+	go s.device.Start(ctx)
+}
+
+func (s *PonSimService) Stop(ctx context.Context) {
+	// Stop PON device
+	s.device.Stop(ctx)
+
+	// Stop GRPC server
+	s.server.Stop()
+}
+
+func main() {
+	var device core.PonSimInterface
+
+	// Init based on type of device
+	// Construct OLT/ONU object and pass it down
+	certs = &grpc.GrpcSecurity{
+		CertFile: path.Join(voltha_base, voltha_cert),
+		KeyFile:  path.Join(voltha_base, voltha_key),
+		CaFile:   path.Join(voltha_base, voltha_ca),
+	}
+
+	// Initialize device with common parameters
+	pon := core.PonSimDevice{
+		Name:        name,
+		ExternalIf:  external_if,
+		InternalIf:  internal_if,
+		Promiscuous: promiscuous,
+		SnapshotLen: snapshot_len,
+		Address:     grpc_addr,
+		Port:        int32(grpc_port),
+		AlarmsOn:    alarm_sim,
+		AlarmsFreq:  alarm_freq,
+		Counter:     core.NewPonSimMetricCounter(name),
+
+		// TODO: pass certificates
+		//GrpcSecurity: certs,
+	}
+
+	switch device_type {
+	case core.OLT.String():
+		device = core.NewPonSimOltDevice(pon)
+		device.(*core.PonSimOltDevice).MaxOnuCount = onus
+		device.(*core.PonSimOltDevice).VCoreEndpoint = vcore_endpoint
+
+	case core.ONU.String():
+		device = core.NewPonSimOnuDevice(pon)
+		device.(*core.PonSimOnuDevice).ParentAddress = parent_addr
+		device.(*core.PonSimOnuDevice).ParentPort = int32(parent_port)
+
+	default:
+		log.Println("Unknown device type")
+	}
+
+	ps := PonSimService{device: device}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	ps.Start(ctx)
+
+	signals := make(chan os.Signal, 1)
+	signal.Notify(signals, os.Interrupt)
+
+	doneCh := make(chan struct{})
+
+	go func() {
+		for {
+			select {
+			case <-signals:
+				log.Println("Interrupt was detected")
+				doneCh <- struct{}{}
+			}
+		}
+	}()
+
+	<-doneCh
+}