• Ruby

ok = s.match?( /#{word}/i )

• C++

auto ok = std::search(std::begin(s), std::end(s), std::begin(word), std::end(word),
    [](auto c, auto d){
        return std::tolower(c) == std::tolower(d);
    }
) != std::end(s);

• C#

bool ok = s.ToLower().Contains(word.ToLower());

• C#

ok = s.Contains(word, StringComparison.CurrentCultureIgnoreCase);

• D

ok = indexOf(word, s, CaseSensitive.no) != -1;

• Elixir

ok = s =~ ~r/#{word}/i

• Erlang

Re = re:compile(Word, [caseless, unicode]),
Ok = re:run(S, Re) =/= nomatch.

• Fortran

 function u_i(string, substr)
  character (len=*), intent(in) :: string, substr
  integer :: i,j, c1, c2, u_i
  u_i = 0
  out: do i=1,len(string)-len(substr)+1
   c1 = iachar(string(i:i))
   if (c1 >= iachar('a') .and. c1 <= iachar('z')) c1 = c1 - 32
   do j=0,len(substr)-2
     c2 = iachar(substr(j+1:j+1))
     if (c2 >= iachar('a') .and. c1 <= iachar('z')) c2 = c2 - 32
     if (c1 /= c2) cycle out
   end do
   u_i = i
   return
 end do out
end function u_i

ok = u_i(string, word) /= 0

• Go

lowerS, lowerWord := strings.ToLower(s), strings.ToLower(word)
ok := strings.Contains(lowerS, lowerWord)

• Haskell

containsIgnoreCase :: String -> String -> Bool
containsIgnoreCase s word = isInfixOf (map toLower word) (map toLower s)

• JS

var lowerS = s.toLowerCase();
var lowerWord = word.toLowerCase();
var ok = lowerS.indexOf(lowerWord) !== -1;

• Java

ok = s.toLowerCase().contains(word.toLowerCase());

• Lua

ok = string.find( string.lower(s), string.lower(word) ) and true or false

• PHP

$ok = stripos($word, $s) === false;

• Pascal

OK := Pos(LowerCase(AWord), LowerCase(S)) > 0;

• Perl

my $ok = $s =~ /\Q$word/i;

• Python

ok = word.lower() in s.lower()

• Rust

let re =
    RegexBuilder::new(&regex::escape(word))
    .case_insensitive(true)
    .build().unwrap();

let ok = re.is_match(s);

• Rust

let re = Regex::new(&format!("(?i){}", regex::escape(word))).unwrap();
let ok = re.is_match(&s);

• Rust

let ok = s.to_ascii_lowercase().contains(&word.to_ascii_lowercase());