Bash + coreutils, 13 bytes

ls -Sar|sed q

PowerShell, 30 bytes

(ls -file|sort length)[0].Name

Try it online!

ls is an alias for Get-ChildItem, with the -file parameter so we only get files. That's piped to sort-object with the length attribute, so the files are sorted by size. We index into that with the (...)[0] to get the first (i.e., smallest), and then take the .Name thereof. Output via implicit Write-Output happens at program completion.

Ruby, 61 40 bytes

Thanks G B

p Dir.foreach(?.).min_by{|x|File.size x}

Python 2 3, 94 76 74 54 bytes

-18 bytes thanks to @orlp
-2 bytes thanks to @Jonathan Allan
-20 bytes thanks to a change in challenge specs

from os import*
print(min(listdir(),key=path.getsize))

Mathematica, 35 bytes

FileNames[]~MinimalBy~FileByteCount

FileNames[] produces a list of names of all the files (and directories) in the current directory; ~MinimalBy~FileByteCount selects the name of the file whose byte count is smallest. FileByteCount throws a bunch of errors when it's applied to directories, but the errors don't derail the program.

MATLAB / Octave, 52 48 bytes

d=dir;[~,n]=min([d.bytes]./~[d.isdir]);d(n).name

Explanation

This gets a directory listing of all files and folders in the current directory using dir. The output of dir is a struct containing the filename, whether it's a directory or not, the size (in bytes), etc.

We can then take an array of the sizes of each in bytes [d.bytes] and perform element-wise division with a boolean indicating whether it's a directory or not ~[d.isdir] which will yield Inf where it's a directory (division by zero) and the size in bytes otherwise (division by 1).

We find the index of the minimum of this array using the second output of min and use that to index into the initial struct and display the name with d(n).name

Batch, 43 39 bytes

@dir/a-d/b/os|(set/pf=&call echo %%f%%)

Output includes a leading space for some reason, but fortunately that's allowed.

Java 7, 149 bytes

String f(){String n="";long s=-1>>>1,p;for(java.io.File f:new java.io.File(".").listFiles())if((p=f.getTotalSpace())<s){n=f.getName();s=p;}return n;}

Try it online!

SmileBASIC, 110 bytes (non-competing)

DIM F$[0]FILES"TXT:",F$FOR I=0TO LEN(F$)-1F$[I][0]="TXT:
S=LEN(LOAD(F$[I],0))IF!Z||S<Z THEN Z=S:B=I
NEXT?F$[B]

Only looks at TXT: files, since DAT: files cannot be loaded unless you already know their size, making it impossible to load a random one. SB doesn't support nested folders, so I don't need to deal with that.

V, 12 bytes

:r!ls -S
kdH

Try it online!

This only works on Linux.

Bash 15 14 bytes

ls -S|tail -n1

-S sorts by size (descending),

-rreverses and tail -n1 outputs the last file in the list.

@ Dennis thanks for saving 1 byte

BATCH File, 77 72 bytes

@FOR /F "tokens=*" %%G IN ('dir /a:-d /o:-s /b') DO @SET F=%%G
@ECHO %F%

There's no direct equivalent of head or tail in BATCH, at least to my knowledge, so here's a kludgy work-around. (with assistance from @Neil - thanks!)

The dir command, with /a:-d to exclude directories, /o:-s to sort in descending file size, and /b to output only the file names. We loop through those with FOR /F, setting the variable F to the file name each time. Finally, we output just the last one with ECHO %F%.

J, 21 bytes

>{.{.(/:2&{"1)1!:0'*'

Explanation

>{.{.(/:2&{"1)1!:0'*'
                  '*' Glob all files in current directory
              1!:0    Table of file metadata in that directory
        2&{"1         Get the file size of each
      /:              Sort the files by that
   {.                 Get the first row
 {.                   Get the first column
>                     Unbox

Perl 6,  33 32  31 bytes

'.'.IO.dir.grep(*.f).min(*.s).put

Try it

put '.'.IO.dir.min:{try .s//Inf}

Try it

put $*CWD.dir.min:{try .s//Inf}

Try it

Expanded:

put        # print with trailing newline
$*CWD.dir  # the list of files in the current directory
.min:{     # find the minimum by
  try .s   # the size
  //       # if it fails ( because it was a directory )
  Inf      # use infinity instead
}

tcl, 76

set s Inf
lmap f [glob -type f *] {
if [file size $f]<$s {set n $f}}
puts $n

demo

Node.js (using walk), 114 bytes

Ignore newline:

require('walk').walk(__dirname).on('file',(r,s,n)=>
(m=s.size>m.size?m:s,n()),m=0).on('end',_=>console.log(m.name))

This invokes a walker that traverses through the current directory (__dirname) and for each file calls a function with its stat s and a function next n() that must be invoked to continue the traversal. Then at the end, it prints a filename with the minimum size in bytes found. s.size>m.size returns false when m.size is undefined, so after the first callback, m is equal to the first file found, and continues from there normally.

PHP, 84 bytes

$t=array_map(filesize,$g=array_filter(glob('*'),is_file));asort($t);echo$g[key($t)];

This is the best I could do. Maybe there is a better way I'm missing.

$t=array_map(              # visit each array element and...
    filesize,              # map each filename to its filesize...
    $g=array_filter(       # using an array of...
        glob('*'),         # all files and directories...
        is_file            # filtered by files...
    )                      # 
);                         # 
asort($t);                 # sort the array of filesizes, then...
echo$g[key($t)];           # print element from the array of files using the first key of the sorted array as an index