►
From YouTube: S316 - .NET Core CLI and Global Tools
Description
.NET Core CLI you work from the command line, outside Visual Studio. You might do this if you're developing on a Mac or Linux box, because you prefer it, or to automate processes. You'll learn how easy it is to use, check out the great documentation, and see how to get tab completion specific to the shell you're using. You can also extend the CLI by writing global tools or using global tools other people have written. See how fast it is to create a global tool and the road map for the future tool ecosystem for .NET Core.
A
B
B
A
I
just
want
to
say:
Kathleen
I
have
been
like
you've
been
my
hero,
my
da
dead
hero,
I've
known
Kathleen,
since
I
started,
John
net
programming
back
in
2002
I
bought
a
book
of
yours
and
you
it
was
cogeneration
in
dotnet
and
over
the
years
like
I
I
met,
you
I,
remember,
meeting
you
and
just
being
like.
Oh
my
god.
This
is
Kathleen
dollar
and
then
we
got
to
know
each
other
may
became
friends.
We
got
our
ears
pierced
to
get.
B
B
B
Does
it's
amazing,
absolutely
amazing,
but
it's
because
it's
an
efficient
way
to
get
things
done
and
that's
why
we've
come
back
to
it
after
long
journey.
You
know
there
was
decades
where
you
could
program
without
really
hardly
ever
typing
at
a
command
line,
and
you
still
can,
if
you're
working
in
visual
studio,
but
it's
really
helpful
to
be
able
to
drop
down
to
the
command
line.
A
B
A
B
Think
that's
true,
especially
for
things
like
like
published,
but
a
lot
of
it
really
parallels
fairly
closely.
I
want
you.
What
you
do
publish
is
a
little
bit
different
and
then
there's
a
little
bit
you're
a
little
bit
clearer
on
when
you're
doing
a
pack
and
restore
can
now
be
a
little
bit
more
explicit.
So
there's
some
things
that
are
just
more
direct,
but
it's
the
same
stuff,
there's
nothing!
It's
not
new
concepts.
It's
just
new
ways
of
it.
B
Okay,
so
I'm
gonna
start
out
talking
about
talking
about
how
you
pick
your
SDK
guy,
something
called
global
JSON
that
some
people
know
a
lot
about,
and
some
people
misunderstand
and
some
people
have
never
ever
heard
of
so
let's
start
with
global
about
JSON
yeah.
So
this
is
a
file
on
your
in
your
project
in
your
repo,
that's
going
to
say
what
SDK
you're
going
to
pick.
B
So,
let's
take
a
look
at
the
command
line,
we'll
jump
down
here
for
a
minute
and
I'll
start
out
by
just
saying
net,
and
you
want
to
know
what's
going
on,
help
is
always
great.
So
then
you
can
find
out
what's
available
in
this
case.
What
we
want
to
do,
because
we
want
to
look
a
global
JSON
is
I'm
going
to
create.
Actually,
first,
let
me
just
create
a
new
directory
that
seems
like
such
a
logical
thing
to
do
and
I'll
just
call
it
dotnet
cough
and
I'll
just
go
to
go
into
that
directory.
B
B
A
bunch
of
them
and
there's
a
lot
more
available
that
are
on
nougat.
You
can
go
to
new,
get
and
search
for
for
templates.
We
are
working
on
a
better
experience
for
being
able
to
find
both
templates
and
the
global
tools.
I'll
talk
about
later
right
now
those
a
little
bit
harder
work,
then.
Obviously
it
would
be
great,
so
I'm
going
to
say
done.
B
A
new
global
dot,
JSON
I,
think
I
have
to
say
global
dot,
JSON,
maybe
I
supposed
to
just
be
one
word
I'm
looking
under
that
second
column
near
the
bottom,
and
it
says
Global
JSON,
so
I'll
just
make
it
one
word.
Okay,
so
it
says
it
was
successfully
created
and
based
on
that
and
I'm
just
gonna.
Let
me
so
I
can
pull
the
bottom
of
that
up
just
a
little
bit.
It's
not
behaving
itself!
Well,
I
just
want
to
bring
that
up
a
little
bit.
So
it's
not
sitting
quietly.
C
B
B
At
that
look
at
that
and
get
the
bot
there
for
you
all
right,
so
I
have
set
code
up
so
that
I
can
just
say
code
on
and
that's
gonna.
Let
me
take
a
look
at
the
at
the
actual
code
of
the
global
DOJ's
I'm
I
just
made
okay.
So
all
it
does
is
say
a
version
and
let
me
make
that
bigger.
Nobody
can
see
that.
B
So
it's
just
going
to
say
the
version
that
we're
currently
using
and
that's
the
latest
version
on
my
machine
I
can
change
that
to
a
different
version
if
I
want
to
run
a
different
version.
So
the
way
I
find
out.
What's
on
my
machine
and
my
machine,
can
you
even
imagine
what
happens
when
you
list
all
the
versions
on
my
machine,
because.
B
A
B
Just
know,
I
can't
get
that
down.
Sorry
I'm,
not
thinking
on
that
one.
Okay,
so
we'll
just
get
it
in
there
somewhere.
Okay,
so
it
tells
you
when
it
says
version,
that's
gonna
be
the
latest
one,
which
is
the
one
that
runs
right
now,
if
I
just
say
if
I
just
say,
dotnet
something.
Okay,
now
I
can
change,
which
one
runs
by
modifying
the
global
JSON,
so
I
could
make
it
ten
hundred
or
a
different
version.
So
you
rarely.
C
B
B
Now,
because
that
wasn't
really
the
driving
force
when
it
was
created,
he
doesn't
do
exactly
what
I
said:
okay
yeah
all
right!
So
we're
aware
that
global
that
JSON
ohmmeter
people
are
out
there
going.
Oh
that's
just
messed
up
it.
We
know
Global's
that
JSON
needs
some
attention.
We
just
have
a
pile
of
things
we're
trying
to
get
to,
and
it's
so.
B
It
goes
forward
on
catches,
so
this
is
good
or
bad
depending
on
your
perspective.
So
if
you
think
yes,
of
course,
I'm
with
the
security
patches,
what
are
you
talking
about
so
if
I
had,
if
I
had
to
dot
one
dot
300
in
the
in
Michael
dot
JSON,
there
is
a
two
dot:
one
dot
301
there
might
be
a
302
I
know,
there's
a
301,
so
it
would
run
the
latest
one
that
if
with
more
on
the
one
that
found
on
the
machine,
if
the
one
you
specified
is
not
there
I
see.
B
A
B
B
B
We
got
them
out
of
sync
a
few
times
it
was
massively
confusing,
and
then
we
had
trouble
on
the
wood
travels
north
right
word
with
challenges
on
the
conversion
into
the
system,
we're
using
right
now,
okay,
so
starting
at
two,
don't
one
two
three
hundred,
then
the
2.1
part
of
lines
between
the
SDK
and
the
runtime.
So
this
is
going
to
stay
this
way,
so
this
is
just
like.
We
think
we're
we're
there.
B
A
B
All
right,
so
what
we
generally
think
for
most
people,
what
we
think
is
best
to
do
is
get
figure
out.
What
run
time
you're
running
and
2.2
is
still
in
preview
so
right
day
it
would
be
2.1
and
get
your
2.1.
You
can
get
the
sdk
and
the
run
time
together,
download
them
together
and
that's
going
to
give
you
the
latest
SDK
and
it
aligns
with
that
run
time.
Okay,.
C
B
Time,
identifier,
which
is
the
way
that
dotnet
dotnet
core,
expresses
what
you're
currently
running,
okay
so
and
we've
got
the
base
path
and
some
other
things
in
there.
Okay,
so
let's
come
back
over
here-
and
this
is
just
my
slide-
deck
just
kind
of
restates
what
I've
already
said
and
that
rolls
forward
only
on
the
patch
version.
Okay,
it
will
otherwise
give
you
in
here
now
there
is
another
reason:
some
people
just
came
in
a
2.1
that
you
may
be
using
global
dot,
JSON
and
I'm
not
going
to
go
into
this.
B
But
if
you
hear
about
custom
tasks
and
targets
or
a
custom
SDK
its
new
tests
and
targets
that
are
coming
in
and
that's
also
defined
in
a
global
debt.
Json,
okay
and
the
way
this
works
is
it
just
starts
it
whatever
it's
wherever
you
did
the
command
and
it
walks
up
your
directory
tree
and
tell
it
either
find
one
or
gets
to
the
top.
So
that
is
that
that
seems
like.
B
B
Could
say:
I
have
hundreds
doing
it
Windows
it's
an
uninstall,
okay,.
B
A
B
B
So
I'll
just
do
a
quick,
clear
this
out
for
you
and
I'm
gonna,
say
dotnet
and
new
console
okay
and
I'm,
going
to
put
that
I'm
in
to.net
cough,
but
I'm
going
to
go
one
level
down
and
dot
I
can
say,
o
or
I
could
say
ed
put
if
you're
from
windows.
That's
the
POSIX
standard
that
we
adopted,
which
is
part
of
UNIX,
and
it's
just
a
little
bit
overall,
more
consistent
than
what
was
going
on
in
Windows.
So
we
decided
to
go
that
route.
B
Okay,
dot,
NIC,
new
console
output,
I
need
to
call
it
something!
So
let's
call
it
hello
world,
okay,
wait!
Just
a
second
does
some
restore
again
I'm,
just
going
to
say,
code
dot
and
I'll
come
up
there.
Now
in
the
I'm
one
level
up
where
I
put
the
global
JSON.
Here's
the
directory
I
just
created
it's
where
I
was
when
I
typed
code,
space,
dot.
Okay
and
now
we
look
at
the
program
file,
hey
that
exciting,
we'll
just
close
that.
So
there
we
go.
C
B
B
C
B
Wanted
to
have
an
application
out
there
that
we
could
play
with
so
creating
an
application
is
super
simple,
you've
seen
stuff
here
at
don't
make
off
about
where
we're
going
with
asp.net
core.
B
B
B
C
B
B
C
A
C
B
A
C
A
B
A
B
B
And
one
of
the
things
that
was
done
there
is
just
like
we've
got
to
make
this
thing
simple:
it
is
stupid,
complicated,
so
there's
ideas
about
globbing
that
are
very
common.
Now
in
the
industry.
Globbing
just
means
you
can
use
a
star
and
get
everything
that
matches
instead
of
having
to
list
every
single
file.
B
B
B
Common
project
system,
because
I
want
to
call
it
the
current
project
system,
and
that
sounds
like
there
might
be
another
one.
So
it's
called
a
common
project
system,
okay
and
it's
called
common
because
they
misspelled
that
it
works
with
actually
can
handle
the
old,
the
original
and
the
the
common.
So.
B
You
shouldn't
have
to
use
everything
you
want
takeaway
yeah.
Let's
take
a
look.
Let's
look
at
so
I
just
built
this,
so
we
could
so
I'll
go
ahead
and
just
give
us
a
little
bit
more
room
here.
Cuz.
We
don't
need
to
see
the
body
more
skilled
it.
This
is
hard,
the
bottom
are
killing
it.
That's
it
that's
that's
all
you
need,
and
in
fact
it
could
be
quite
a
complex
project
and
that's
still
be
all
you
need,
because
it
knows
well,
you
know.
B
C
C
C
B
Yeah
yeah
yeah,
we
we,
we
won't
talk
about
it.
It's
all
to
XML,
allows
comments
and
it
allows
a
very
clear
two
levels
of
information.
It
allows
the
actual
node
and
it
allows
attributes
on
the
node
and
those
two
levels
working
together
can
make
for
very
simple
explanations
of
the
importance
and
what
things
relate
to
so
it's
it's
a
nice
system
for
for
a
project
system
for
anything
with
some
complexity.
Okay
to
it
and
did.
B
Right,
there's
no
system,
while
it's
the
new
common
project
system
can
read
both
original
files
and
common
files
and
the
old
one
has
no
idea,
because
it's
all
about
the
about
the
common
fossa,
so
you
can't
use
them
right
all
right.
So
because
there's
two
built
systems,
you
might
need
to
access
them
both
from
the
CLI
that
can
happen.
You
could.
B
Sorry
I
forgot,
but
that's
the
way
you
on
the
command
line
with
dotnet
CLI.
You
MS
feel
slash,
T
and
I.
Don't
remember
what
the
slash
T
stands
for.
I
sorry
about
that
legit!
It's
somebody
on
the
teams
watching
you
can
jump
in
here
and
remind
me
of
what
slash
T
stands
for,
but
anyway,
this
just
talks
about
the
different
which
what
each
one
of
them
does.
B
C
B
C
B
C
A
B
B
B
B
B
B
B
We
do
not
see
a
project
file,
so
would
you
mind
telling
us
what
we
should
do
and
I
could
have
done
this?
A
few
other
ways.
I
could
have
told
it
where
the
file
was,
but
instead
I
just
changed
the
directory,
and
now
when
I
say
build,
it
should
come
back
and
it's
doing
the
restore
and
it
says,
build,
succeeded.
A
C
B
A
B
B
Directory
but
I've
messed
myself
up.
This
is
not
how
you
run
an
application
I
just
placed
on
this
is
not
how
you
run
this
application.
I'm
gonna
talk
more
about
this,
but
this
is
a
DLL.
So
if
we
actually,
let's
do
something
to
make
our
life
a
little
bit
easier
here.
I'm
gonna
go
back
to
this,
build
okay
and
I'm
gonna,
say
I'm
gonna,
give
it
an
output
directory
which
I'm
going
to
call
FD
app
I'll.
B
Explain
that
a
why
I'm
calling
at
that
and
so
now
I
should
be
able
to
kill
the
bin
and
obj
directories
and
I
want
to
show
what's
in
that
directory,
so
I
just
call
it
FD
up,
and
so
now.
This
is
where
my
output
of
the
bill
just
went
and
I'll
tell
you
what
hello
world
worked
in
just
a
minute,
because
that
is
really
the
real
question
right
now
is
why
to
tell
the
world
work.
So
if
you
see
here
there's
a
couple
of
files,
but
you
will
see
that
there
is
no
executable
file
right.
B
Okay,
because
by
default
we
build
dll's,
dotnet
corbels
dll's,
not
executables,
okay.
So
what
I
need
to
do
to
actually
run
this,
and
let's
do
that
first,
is
to
say
net
and
then
I
need
to
give
it
the
from
here.
How
do
I
find
that
executable
and
I'm,
not
in
the
FT
app
directory,
so
I'll
say
that
first
and
then
I'll
say
hello,
world
and
then
I'll
say
DLL
and
now
I
should
say
hello
done
it
cough
okay,
now
step
one:
okay,
okay,.
A
B
C
B
It's
something
that
it's
a
console,
app,
okay,
that
when
we
install
it,
we
put
a
special
shim
on
it
so
that
it
acts
like
an
executable
and
I'll
talk
more
about
that
shim
and
what
we're
doing
with
that
whole
idea.
Okay!
So
with
the
with
the
shim
on
that,
and
then
we
put
it
into
your
path.
Okay,
so
what
a
global
to
Liz
isn't
executable
that
we
helped
you
create.
B
B
It's
like
so
it
makes
a
CLI
extensible.
It
absolutely
makes
this
a
no,
and
we
do
the
install
comes
through
new
get,
so
we
already
have
a
good
place,
a
good
place
to
go
put
them
okay,
some
people
can
find
them
we're
definitely
working
through
kinks
on
this
particularly
they're
hard
to
find
right
now:
okay,
we
don't
yet
have
a
good
search
and
that
it's
just
because
we
have
to
coordinate
a
lot
to
make
that
happen,
but
if
you
go
to
new,
get
and
we're
working
on
being
able
to
search
for
tools,
I
think.
B
B
No
matter,
but
if
somebody
wants
to
work
on
that
and
just
we
just
need
you
know
a
website
someplace
that
has
a
has
the
ability
to
give
it
get
back
to
list,
preferably
with
some
stats
and
ownership.
They
can
give
a
list
in
a
global
tool
that
can
then
just
display
those.
So
we
haven't
written
that
yet
we
know
we
bet
this
is
badly
needed,
but
it's
you
know
if
somebody
wants
to
write
that
just
I'll.
B
B
B
B
Then
I
need
to
give
the
path
to
the
diello,
which
is
FD
up
and
then
hello,
world
and
then
I
need
to
give
the
DLL
as
well
and
now
the
nut
is
it's
an
application
of
course,
and
that
our
location
can
do
several
different
things,
one
of
which
is
act
as
an
app
host
to
run,
as
it
is
right
now
to
run
a
deal
in
alright.
So.
A
B
So
let's
talk
about
that-
and
this
really
should
not
be
executable
as
I
should
have
named
this
section,
a
little
bit
more
like
running
stuff,
and
you
just
saw
one
way,
the
common
way
to
run
stuff,
and
so
it's
like
I
want
to
go
fix
my
slide
here.
It's
really
annoying
me
that
much
and
you
can,
let
me
fix
my
song.
You're
gonna
do
life
at.
B
B
B
C
B
It's
got
a
simple
publish
directory,
it
was
small,
you
have
to
type
the
name
of
it
and
all
apps
share
the
same
copy
of
the
framework.
This
is
super
important
because
it's
going
to
go
and
run
the
runtime.
Now
we
had,
we
talked
about
how
to
get
the
right
SDK
earlier
now
we're
talking
about
what
runtime
is
going
to
be
in
place.
Okay,
so
every
Apple
on
the
machine
can
use
the
same
version.
The
framework
so
I
I'm,
saying
that
a
little
bit
too
generally,
because
you
can.
B
The
project
file
normally
lists
what
your
target
framework
is.
So
what
what
version
of
the
framework
you
want
to
run
against?
Okay,
so
one
app
might
be
running,
gets
to
I
when
one
might
be
running.
It
gets
to
one
okay,
all
good,
okay,
so
and
in
asp.net
in
particular.
This
is
good
because
you
may
have
many
apps
on
one
machine
also
means
that
your
operations
team
determines
when
you
have
an
updated
version
of
the
runtime.
B
So
if
a
patch
comes
out,
then
the
operations
team
decides
whether
or
not
to
a
plan
you're
going
to
apply
that
okay.
So
the
next
thing
that
we've
got
is
called
a
self-contained
at
okay,
a
self-contained
app,
isn't
executable
and
I'm
going
to
build
one
in
just
a
second.
It's
got
a
rather
large
public
directory.
We
can
take
a
look
at
that.
It
does
create
an
executable.
It
does
create
a
very
big
hello
world
I
think
it's
about
250
megabytes,
it's
great
for
a
standalone
deploy.
B
B
It
see
I'll
show
you
that
in
a
second-
and
one
thing
I
want
to
point
out
here,
is
that
you
see
that
it
says
R
and
that
stands
for
the
runtime
that
you're
the
framework
that
you're
running
against
it's
actually
the
platform,
I'm,
sorry
that
you're
running
on
and
so
with
dotnet
published.
Then
if
you
say
R,
then
it's
going
to
go
for
that
specific
platform.
So,
let's
take
a
look
and
see
what
that's
going
to
look
like.
Is
this
going
to
come
up?
It
didn't
come
on
I.
C
B
B
Dotnet,
publish
and
the
publish
only
puts
things
into
the
right
output
directory
when
you're
just
doing
a
framework
dependent
app
because
I
don't
that
much
to
it,
but
now
we're
going
to
say
are
and
I'm
on
iOS
x64
trying
to
remember
what
the
writ
is.
I'll
tell
you
what
you
do
when
you
can't
remember.
B
C
B
Now
we're
going
to
do
an
output
and
we're
going
to
just
call
this
self-contained
app,
so
we'll
create
a
new
directory
and
that
way
we're
going
to
be
able
to
compare
the
all
right
cool.
So
we
get
another
successful,
build
and
I
wasn't
published.
That's
why
we
didn't
get
both
bills,
succeeded,
Oh,
published
right,
okay,.
C
B
Have
any
Garnett
on
it
and
I
don't
want
that
alert.
So
what
you're
saying?
Yes,
we
absolutely
can't
it
look
it's
a
lot
of
stuff
alright.
So
this
is
great
for
some
situations:
okay,
but
these
two
together
really
aren't
everything
that
we
should
have.
We
have
some
more
things
coming
and
that's
where
that
next
slide
says.
A
Right,
we
got
a
question
while
you're
figuring
that
out
what
if
we
want
to
make
a
JIT
compiler
interpreter
for
da
net
core,
the
goal
is
to
run
I'm
thinking,
asp.net
apps
or
done
it
ups
without
recompiling
all
the
app
every
time
we
save
a
file.
I,
probably
ask
me
not:
instead,
we
compile
in
the
runtime
only
what
we
need
to
run
just
like
PHP
is
that
applicable?
If
so,
what
do
we
need
to
know
to
accomplish
that?
So
they
basically.
B
B
Automatically
I
will
tell
you
that
I
have
kind
of
a
knee-jerk
reaction
that
that's
gonna
be
super
hard,
but
I
also
know
that
some
of
the
folks
that
work
on
the
compiler
team
blow
me
away
sometimes
they're
pretty
smart,
yeah,
oh
yeah,
so
basically
we
have
an
incremental
compiler.
It
builds
this
big,
you
know
syntax
semantics
trees
and
they,
then
that
normally
outputs
and
we
run
from
there
you'd
have
to
hold
that.
Basically,
because
the
way
that
this
strongly
typed
language
works
is
you've
got
to
kind
of
have
all
your
references.
B
B
Right
right
and
I
don't
know,
that's
an
area
that
the
the
CLI
scenario
right
now
we
do
spin
up
the
process
and
kill
it
spin
up
the
process
and
kill
it,
and
we
we've
done
a
little
bit
of
work
with
some
background
stuff
to
get
some
of
the
JIT
to
speed
things
up,
but
sometimes
I
do
wake
up
at
night
and
wonder
whether
we
should
actually
be
keeping
something
running
in
the
background
for
the
purpose
of
performance
and
some
other
things.
Let's.
B
Right,
fantastic,
so,
let's
go
back
to.
Let's
go
back
to
my
slides
for
a
second,
so
I'll
talk
about
framework
dependent,
executable,
and
so
this
is,
it
has
a
simple
published
directory.
The
executable
gets
created
and
apps
share
a
framework,
okay
and
it
rolls
for
it.
So
it's
got
the
best
of
these
two
worlds
together.
What
we
basically
do
is
that
an
executable
has
to
be
specific
to
the
platform.
B
C
B
So
wound
up
happening
and
we
put
it
out
first
with
global
tools,
because
it
just
happened.
We
could
control
the
creation
very
carefully
there
because
we're
in
charge
of
that
process.
So
we
created
the
shim
that
we
use
for
global
tools,
and
that
was
the
first
place
we
saw
this
and
now
this
is
is
going
to
be
coming
out
in
either
to
200
or
300
I.
B
Don't
know
what
milestone
we're
hitting
it
on,
but
this
is
the
way
you
get
to
that
and
I'm
actually
going
to
skip
showing
you
what's
in
the
directory,
but
it's
almost
like
the
first
directory,
where
we
just
had
the
DLL
and
a
couple
of
other
things:
there's
a
DLL
and
an
executable
because
we're
creating
that
shim
for
you.
That's
still
calls
in
but
I
mean.
C
C
C
A
B
A
B
B
Okay,
and
so
that
was
the
challenge
of
getting
that
done
and
that
work
is
now
it's
done
and
if
you
have
nightly
bills,
you
can
take
a
look
at
it
and
it's
just
going
to
be
a
little
tiny
bit
bigger
than
the,
and
we
know
this
is
something
people
have
been
waiting
for
and
we're.
So
we're
very
excited
that
we've
got
it
at
a
point
that
we're
comfortable
releasing
it
because
we
know
it's
it's.
It
means
that
you
can
start
looking
at.
We
can
well.
B
B
B
C
B
B
How
this
works
and
because
I'm
a
little
afraid
of
having
my
machine
go.
We
have
a
rise
of
global
tools.
Let's
talk
about
global
tools,
global
tools
are
available
right
now
you
get
them
by
saying
dot,
net
tool,
install
/gm
my
tools,
slash
G
stands
for
global
and,
yes,
the
implication
is
we
will
do
local
tools
and
that's
consistent
with
NPM.
B
We
don't
want
you
to
have
to
think
two
different
ways,
one
when
you're
doing
NPM
package
management
and
one
when
you're
doing
dotnet
package
management,
so
we
use
nougat
with
all
the
nougat
things,
including
you
get
config.
So
you
can
go
to
your
own
feeds.
You
can
go
to
whatever
your
own
feeds.
Are.
You
can
go
locally
if
you
like,
so
this
is
installed
in
your
path.
I
talked
about
this
earlier.
B
B
So
we're
coming
we're
working
on
the
would
still
work
on
the
details,
but
we're
working
on
details
of
what
will
be
local
tools
for
awhile.
We
call
this
repo
tools,
but
we
honestly
don't
know
where
your
repo
is.
So
we
can't
it
sounds
like
we
know,
and
we
don't
so
we're
just
going
to
call
it
local
tools
and
this
works
differently.
B
It
won't
have
a
G,
it
might
have
a
local
but
we're
leaning
right
now,
just
like
nvm.
If
you
don't
have
G
it's
local.
So
that's
what
we're
leaning
right
now!
Okay,
again,
we
don't
want.
You
have
to
think
differently
when
you
come
to
dotnet
land,
also
from
Neoga
and
there's
a
repo
manifest
now,
and
so
what
we
expect
to
happen
is
that,
from
whatever
you
run
a
command,
it
will
start
looking
if
you
say
and
you'll
say
dotnet
for
this,
because
you
have
to
be
in
our
world.