Jelly, 1 byte:

ḍ

This took me hours to golf.

Try it online!

Brain-flak 102, 98, 96 bytes

(({}<>))<>{({}[()])<>(({}[()])){{}(<({}[({})])>)}{}({}({}))<>}{}<>([{}]{}){<>(([()])())}({}{}())

Eww. Gross. I might post an explanation, but I barely understand it myself. This language hurts my brain.

Try it online!

Thanks to github user @Wheatwizard for coming up with a modulus example. I probably could not have figured that out myself!

Possibly incorrect explanation:

(({}<>))                    #Push this element onto the other stack
<>                          #Move back to stack one.
{                           #While the top element is non-zero:
 ({}[()])                   #  Decrement the number on top
 <>                         #  Move to the other stack
 (({}[()]))                 #  Push the top element minus one twice
 {                          #  While the top element is non-zero:
  {}                        #    Pop the top element
  (<          >)            #    Push a zero
        ({})                #    Push the second from top element
       [    ]               #    Evalue this second from top element as negative
    ({}      )              #    And push that negative plus the top element
 }
 {}                         #  Pop the top element
 ({}({}))                   #  Push the top element plus the second from the top, AND push the second from top
 <>                         #  Switch stacks
}

{}                          #Pop the stack
<>                          #Switch to the other stack
([{}]{})                    #And push the top element minus the second element.

The rest is pretty straightforward.

{              }            #While the top element is non-zero:
 <>                         #Move to the other stack
   (([()])  )               #Push a negative one
          ()                #AND push the previously pushed value + 1 (e.g. 0)

                 (      )   #Push:
                  {}{}      #The top two elements added together
                      ()    #Plus one

CJam, 6 4 bytes

Saved 2 bytes thanks to Dennis

q~%!

Try it online

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT

Retina, 12 bytes

^(1+)\1* \1$

Takes space-separated input in unary, like 111111111111 1111 to check if 12 if divisible by 4. Prints 1 (true) or 0 (false).

Try it online!

FryAmTheEggman saved two bytes. Oops, rewrote my answer to take the arguments in the right order. (Then Fry beat me to it in the comments. I’m slow at regex!)

Vim, 11 keystrokes

C<C-r>=<C-r>"<C-Left>%<C-Right><1<cr>

Not bad for a language that only handles strings. :D

Hexagony, 15, 13, 12 10 bytes

Everybody's favorite hexagon-based language! :D

Saved 2 bytes thanks to @MartinEnder's layout wizardry.

@FryAmTheEggman saved 1 byte by using the corners more creatively

Both @MartinEnder and @FryAmTheEggman came up with a 10 byte solution that doesn't print anything for falsely values.

My solution (15):

Unformatted:

?{?..>1'%<.@!'/

Formatted:

  ? { ?
 . . > 1
' % < . @
 ! ' / . .
 . . .

@Martin Ender's Solution (13):

Unformatted:

?{?!1\.'%<@.>

Formatted:

  ? { ?
 ! 1 \ .
' % < @ .
 > . . .
  . . .

Explanation:

First, we get the input and take the modulus.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Then, it checks if the modulus is 0 or not. If it is, the IP turns 60 degrees left, bounces off the mirror, sets the cell to 1 and prints.

Then, the IP continues onto the fourth row. When it reaches the >, it turns to the right instead (because the value of the cell is now 1). It goes oob, and comes back in the bottom right corner heading NW. The IP hits the <, goes along the top row, and comes back in the right corner to hit the @, stopping the program.

  . . .
 ! 1 \ .
. . < @ .
 > . . .
  . . .

If the modulus turns out to be positive, the IP turns 60 degrees to the right. Once it goes out the bottom right corner, it continues on the bottom left edge because of Hexagony's wrapping rules. The ' is reused to make the IP go to a cell with 0 in it. The IP then travels along the fourth row, wraps around to the second, hits print, and gets reflected into the <. The rest of the path to the @ is the same.

  . . .
 ! . \ .
' . < @ .
 > . . .
  . . .

That's some serious wizardry.

@FryAmTheEggman's Solution:

Unformatted:

?{?\!1@'%\!(

Formatted:

  ? { ?
 \ ! 1 @
' % \ ! (
 . . . .
  . . .

Explanation:

Like the other solutions, it gets the input and takes the modulus.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Then, the IP gets deflected into the bottom corner. If the modulus is positive, it goes on the top left edge. The ? has no more input, so it sets the cell to 0. The ! then prints the 0, and the @ terminates the program.

  ? . .
 \ ! . @
. . \ . .
 . . . .
  . . .

Things are much trickier for when the modulus is 0. First of all, it gets decremented, then reset to 0, then set to 1, then printed. Then, the 1 gets decremented to 0. After that, the program runs like it does at the beginning until it tries to do 0%0. That makes it throw a silent error and quit.

  ? { ?
 . . 1 .
' % \ ! (
 . . . .
  . . .

I really like the silent error trick.

Collaborative solution (10):

Unformatted:

?{?!1\@'%<

Formatted:

  ? { ?
 ! 1 \ @
' % < . .
 . . . .
  . . .

This program starts out the same as all the other programs, getting the input and modding it.

If the input is 0, the IP turns left when it hits <. It gets deflected into 1!@, which prints 1 and quits.

  . . .
 ! 1 \ @
. . < . .
 . . . .
  . . .

If the input is positive, the IP turns right when it hits <. It exits through the corner, and goes along the top right edge hitting the @ without printing.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .

Dyalog APL, 3 bytes

0=|

Is zero equal to the division remainder?

GolfScript, 3 bytes

~%!

Explanation:

~    # Evaluate the input
 %   # Take the first modulus the second
  !  # Boolean not

Try it online!

Batch, 20 bytes

@cmd/cset/a!(%1%%%2)

Outputs 1 on success, 0 on failure.

brainfuck, 53 bytes

Takes input as bytes, output is a byte value of 0x00 or 0x01. It's the DivMod algorithm followed by Boolean negation.

,>,<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>,>[<+>,]+<[>-<-]>.

Try it online - Has a bunch of extra + near the end so you can see the output in ASCII.

Python, 16 bytes

lambda D,d:D%d<1

Javascript ES6, 17 12 11 bytes

a=>b=>a%b<1

• EDIT: Removed 5 bytes because 'a>0' is expected.
• EDIT2: Removed 1 byte thanks to Downgoat.

Julia, 9 bytes

D\d=D%d<1

Try it online!

Actually, 3 2 bytes

%Y

Saved one byte thanks to @Mego.

Try it online!

LOLCODE, 74 64 bytes

HOW IZ I f YR a AN YR b
BOTH SAEM MOD OF a AN b AN 0
IF U SAY SO

Brachylog, 2 bytes

%0

Try it online!

Fortran 95, 78 bytes

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f

MATL, 2 bytes

\~

Try it online!

\    % Take two inputs implicitly. Compute their modulo
~    % Logical negate. Implicit display

Befunge, 6 bytes

&&%!.@

Try it here! Input two numbers, separated by a space. Output is 0 or 1 for falsy or truthy.

MarioLANG, 121 109 107 bytes

Saved 14 bytes thanks to Martin Ender

;>(-)-)+(([!)
)"=========#[
; +(![-)< )<!+
  ==#==="  "#:
>!< >(+ !![(<
=#"="===##=:"
  !      <
  #======"

Try it online!

Explanation

The algorithm is simply to keep subtracting d from n to see if you can do it an integer number of times and have no remainder.

;
)
;

>
=
 
 

First, the input is collected. n is in the first cell, d in the second.

 >(-)-)+(([!
 "=========#
          )<
           "
 !
 #"="===##=
  
  

This is essentially the main loop. It decrements the first and second cells, and increments the third.

           [!)
           =#[
             !+
             #:
            (<
            :"
 
 

This is the final output. If after the incrementing/decrementing, the first cell is 0, then we've eliminated n. If after this, the second cell (d) is 0, then d went into n evenly. We increment and print (1). Otherwise, move back to the first cell (which is 0) and print it.

 
 
  +(![-)<  
  ==#==="  
 !< >(+ !![
 #"="===##=
  !      <
  #======"

This loop happens if the second cell is 0 after incrementing and decrementing. It copies the third cell to the second cell. The part at the bottom is to bypass the loop if the cell is not 0.

C, 60 Bytes

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}

Pyke, 2 bytes

%!

Try it here!

not (a mod b)

Minkolang 0.15, 6 bytes

nn%,N.

Try it here!

Explanation

nn        Take two numbers from input
  %       Pop b, a and push a%b
   ,      NOT top of stack
    N.    Output as number and stop.

Perl 5, 14 bytes

A subroutine:

{!((pop)%pop)}

See it in action thus:

perl -E"say sub{!((pop)%pop)}->(3,17)"

First argument is d, second is n.

Labyrinth, 8 bytes

??
@%
!1

Input is just the two numbers, using any non-numeric separator of your choice. Output is either 1 for truthy or nothing at all for falsy.

Try it online!

Explanation

There's only one branch in the execution and that's after the modulo (%). When the input is a truthy case, the following is executed:

?   Read integer and push onto stack.
?   Read integer and push onto stack.
%   Take the first modulo the second integer. The result is zero, so the
    instruction pointer keeps moving south.
1   Turn that zero into a one.
!   Print it.
@   Terminate the program.

Otherwise, the following code is executed:

?   Read integer and push onto stack.
?   Read integer and push onto stack.
%   Take the first modulo the second integer. The result is positive, so
    the instruction pointer turns west.
@   Terminate the program.

Racket, 26 bytes

(λ(n m)(integer?(/ n m)))

05AB1E, 6 bytes

II%0Q,

Uses CP-1252 encoding. Try it online!

You can also use the built in

Ö

which does exactly what the challenge asks. Just that the 2 inputs are swapped. Try it online!

C#, 27 13 Bytes

(a,b)=>a%b<1;

Thanks to TuukkaX for pointing out anonymous lambdas are acceptable.

Short and sweet, since we're only dealing with integers we can use <1 rather than ==0 and save a whole byte.

Bash, 23 bytes

expr `expr $N % $D` % 2

I'm sure it can be even shorter...

Output is 0 if N is divisible by D, 1 if it is not

Tcl , 34 bytes

ge stdin a
ge stdin b
exp $a%$b<1

My first /*successful*/ attempt in codegolf ! This code must be executed in Tcl shell , otherwise it will not work.

One byte thanks to @Lynn .

Four bytes thanks to @Lynn and @LeakyNun (now I understand what he meant)!