UTAH OUTDOOR ADVENTURE TRAVEL and UTAH VACATIONS by UTAH OUTVENTURES! TRAVEL UTAH! - Click to contact us
UOV layout top
Left Nav Img
Nav Top Img

 

 

 

 

 

 

 

 

 

 

 

 

 

Todays Date:
 
Travel News, Discounted Tours, Specials - Sign Up for Our:
 
Add This Page To Your Favorites
 
Valid HTML 4.01 Transitional

 

 

We Operate Year Round - Contact Us Today!

Nav Right Img
Nav Body Top

Utah Outventures OUTDOOR GEAR SHOP - We have teamed up with the foremost outfitters to bring you the highest quality gear at competitive prices. Utah Outventures staff utilizes the gear we sell. bringing it to test every day out in the field, we know you will find what you are looking for, knowing that you bought the right gear from the right place.

SkI: To some a sport, to others a lifestyle. The most cutting edge tools you need to ski up, down, or across the mountain are all here.

CLOTHING: Nothing can ruin a day in the backcountry faster than not having the right clothing. After countless hours of gear testing, we've selected the best in technical wear & casual clothing from industry leaders.

CAMP / HIKE: Sunrise over a high alpine lake. A trek in the mountains. Pitching a tent far from the city...the backcountry beckons. After years of fieldwork, we've compiled the most technical, high-quality camping, backpacking & hiking gear by Kelty, Lowa, MSR, The North Face and more.

TRAVEL: Not everyone who wanders is lost. Explore, experience, engage. Herein lie the tools to keep you packed & organized, safely hydrated, and on the trail…when you want to be. Choose from Eagle Creek, Jansport, The North Face, Katadyn and more.

 
Men's Clothing
Women's Clothing
Camp/Hike
Bike
Climb
Travel
Kids'
Trail Run
Ski
Snowboard
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